def upgrade(context, logger=None):
setup = getToolByName(context, 'portal_setup')
setup.runAllImportStepsFromProfile(PROFILE_ID)
try:
auth_step_timeout = api.portal.get_registry_record(
name='plone.auth_step_timeout', default=None)
except api.exc.InvalidParameterError:
auth_step_timeout = None
if not auth_step_timeout:
registry = getUtility(IRegistry)
auth_timeout_field = field.Int(
title=u"(Seconds) This amount of inactivity \
will reset the login process",
description=u"Between each step, the allowed \
time is reset to this amount",
default=120)
auth_timeout_record = Record(auth_timeout_field)
registry._records['plone.auth_step_timeout'] = auth_timeout_record
try:
disclaimer = api.portal.get_registry_record(
name='castle.show_disclaimer', default=None)
except api.exc.InvalidParameterError:
disclaimer = None
if not disclaimer:
registry = getUtility(IRegistry)
show_disclaimer_field = field.Bool(
title=u'Show disclaimer for first time a user visits a site. '
u'To comply with ePrivacy Directive, use this feature to notify about cookie use.',
default=False,
required=False)
site_disclaimer_field = field.Text(
title=u"Disclaimer",
default=u'<p><strong>Disclaimer</strong> '
u'<em>You are seeing this because this is your first time visiting the site.</em></p>',
required=False)
show_disclaimer_record = Record(show_disclaimer_field)
site_disclaimer_record = Record(site_disclaimer_field)
registry._records['castle.show_disclaimer'] = show_disclaimer_record
registry._records['castle.site_disclaimer'] = site_disclaimer_record
transaction.commit()
update_password_expiry(api.portal.get())
for id in context.objectIds():
context[id].reindexObject(idxs=['has_private_parents'])
def plumi4to41(context, logger=None):
# add html5 field to transcode.star registry
registry = getUtility(IRegistry)
html5_field = Field.Choice(title = u'Choose video embed method',
description=u"Choose if you would like to use just the HTML5 video tag, or Flash (Flowplayer) or if you would like to use HTML5 with Flowplayer as failback for browsers that don't support the HTML5 video tag",
values = ['HTML5 video tag', 'HTML5 Flash fallback', 'Flash - Flowplayer'],
default = "HTML5 Flash fallback",
)
html5_record = Record(html5_field)
registry.records['collective.transcode.star.interfaces.ITranscodeSettings.html5'] = html5_record
#update user favorite folders
users = context.acl_users.getUsers()
pm = context.portal_membership
addable_types = ['Link']
for user in users:
mf = pm.getHomeFolder(user.getId())
try:
favs = mf.Favorites
if base_hasattr(favs, 'setConstrainTypesMode'):
favs.setConstrainTypesMode(1)
favs.setImmediatelyAddableTypes(addable_types)
favs.setLocallyAllowedTypes(addable_types)
except:
pass
def test_import_dict_nopurge(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element key="x">4</element>
<element key="y">6</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.Dict(title=u"Simple record",
key_type=field.ASCIILine(title=u"Key"),
value_type=field.Int(title=u"Val")),
value={'a': 1})
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.Dict))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals({
'a': 1,
'x': 4,
'y': 6
}, self.registry['test.registry.field'])
def test_import_collection_nopurge(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element>4</element>
<element>6</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = Record(field.Set(
title=u"Simple record", value_type=field.Int(title=u"Val")),
value=set([1]))
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.Set))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals(frozenset([1, 4, 6]),
self.registry['test.registry.field'])
def run(self):
logger.info("Migrating to collective.documentgenerator 11 ...")
registry = getUtility(IRegistry)
records = registry.records
key = "collective.documentgenerator.browser.controlpanel.IDocumentGeneratorControlPanelSchema.use_stream"
current_record = api.portal.get_registry_record(key)
value = True
if current_record is False:
value = u"auto"
record = Record(
field.Choice(
title=
u"Force communication via in/out stream with LibreOffice.",
description=
(u"If enabled, this will force using stream to communicate witth LibreOffice server. "
u"This must be true if the LO server is not on localhost or is in a docker container."
),
vocabulary="collective.documentgenerator.ConfigStream",
),
value=value,
)
records[key] = record
api.portal.set_registry_record(key, value)
self.finish()
def action_addfield(self, action):
data, errors = self.extractData()
self.submitted = True
if not errors:
field_class = getattr(registry_field, data['field_type'], None)
if field_class is None:
notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError('field_type',
Invalid('Invalid Field'))))
return
if data['name'] in self.context:
notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError(
'name', Invalid('Field name already in use'))))
return
new_field = field_class(title=data['title'],
required=data['required'])
new_record = Record(new_field)
self.context.records[data['name']] = new_record
messages = IStatusMessage(self.request)
messages.add(u"Successfully added field %s" % data['name'],
type=u"info")
return self.request.response.redirect('{url}/edit/{field}'.format(
url=self.context.absolute_url(), field=data['name']))
def __setitem__(self, name, value):
records = self.records
if name in records._values:
records[name].value = value
return
record = Record(records[name].field, value)
records[name] = record
def test_multiple_operations_multiple_found(self):
self.registry.records["%s.operations" % Chain.prefix] = Record(
field.List(), ['op1', 'op2'])
view = DummyView()
request = DummyRequest(view, DummyResponse())
class DummyOperation1(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return u"foo"
def modifyResponse(self, rulename, response):
response['X-Mutated-1'] = rulename
provideAdapter(DummyOperation1, name="op1")
class DummyOperation2(object):
implements(ICachingOperation)
adapts(Interface, Interface)
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return u"bar"
def modifyResponse(self, rulename, response):
response['X-Mutated-2'] = rulename
provideAdapter(DummyOperation2, name="op2")
chain = Chain(view, request)
ret = chain.interceptResponse('testrule', request.response)
self.assertEquals(u"foo", ret)
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({'X-Cache-Chain-Operations': 'op1'},
dict(request.response))
request = DummyRequest(view, DummyResponse())
chain = Chain(view, request)
chain.modifyResponse('testrule', request.response)
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals(
{
'X-Mutated-1': 'testrule',
'X-Mutated-2': 'testrule',
'X-Cache-Chain-Operations': 'op1; op2'
}, dict(request.response))
def set_password(self, value):
"""Setter."""
registry = getUtility(IRegistry)
if PASSWORD_REGISTRY_KEY not in registry:
password_field = field.TextLine(title=u"Password for passwordwall")
password_record = Record(password_field, value=value)
registry.records[PASSWORD_REGISTRY_KEY] = password_record
else:
registry[PASSWORD_REGISTRY_KEY] = value
def set_buttons_babel_view_up_to_nr_translations(self, value):
# Backwards-compatibility for installations of PAM before this
# field was added.
# If no entry is present in the registry, initialize it with a
# dummy value
name = "%s.buttons_babel_view_up_to_nr_translations" % \
IMultiLanguageExtraOptionsSchema.__identifier__
if name not in self.registry.records:
int_field = registry_field.Int()
self.registry.records[name] = Record(int_field)
self.settings.buttons_babel_view_up_to_nr_translations = value
def test_use_default_layout_in_registry(self):
transform = theming.getTransform(self.portal, self.request)
layout_name = transform.get_layout_name(self.portal)
self.assertEqual(layout_name, 'index.html')
registry = getUtility(IRegistry)
field = registry_field.TextLine(title=u'Default layout',
required=False)
new_record = Record(field)
registry.records['castle.cms.default_layout'] = new_record
registry['castle.cms.default_layout'] = u'foobar.html'
layout_name = transform.get_layout_name(self.portal)
self.assertEqual(layout_name, 'foobar.html')
def test_chained_operations_not_found(self):
self.registry.records["%s.operations" % Chain.prefix] = Record(
field.List(), ['op1'])
view = DummyView()
request = DummyRequest(view, DummyResponse())
chain = Chain(view, request)
chain.modifyResponse('testrule', request.response)
self.assertEquals({'PUBLISHED': view}, dict(request))
self.assertEquals({}, dict(request.response))
def initialize_default_layout_registry_values(portal):
registry = getUtility(IRegistry)
records = (
('plone.defaultSiteLayout', u'Default site layout',
u'The default site layout for the site', None),
('plone.defaultAjaxLayout', u'Default ajax layout',
u'The default ajax layout for the site', None),
)
for key, title, description, value in records:
if key not in registry.records:
registry.records[key] = Record(
field.BytesLine(title=title,
description=description,
required=False), value)
def setFunctionForOperation(self, operation, function):
function_field = field.ASCIILine(title=u"Operator")
function_record = Record(function_field)
function_record.value = function
self.registry.records[operation] = function_record
