def initialize(context):
registerMultiPlugin(LDAPPlugin.meta_type)
context.registerClass(LDAPPlugin,
permission=add_user_folders,
icon=os.path.join(zmidir, 'ldap.png'),
constructors=(manage_addLDAPPluginForm,
manage_addLDAPPlugin),
visibility=None)
def initialize(context):
registerMultiPlugin(LDAPPlugin.meta_type)
context.registerClass(
LDAPPlugin,
permission=add_user_folders,
icon=os.path.join(zmidir, "ldap.png"),
constructors=(manage_addLDAPPluginForm, manage_addLDAPPlugin),
visibility=None
)
def initialize(context):
"""Initialize the PasswordStrength plugin."""
registerMultiPlugin(PasswordStrength.meta_type)
context.registerClass(
PasswordStrength,
permission=add_user_folders,
constructors=(manage_addPasswordStrengthForm, manage_addPasswordStrength),
# icon='www/noduplicatelogin.png',
visibility=None,
)
def initialize(context):
"""Initialize the NoDuplicateLogin plugin."""
registerMultiPlugin(NoDuplicateLogin.meta_type)
context.registerClass(NoDuplicateLogin,
permission=add_user_folders,
constructors=(manage_addNoDuplicateLoginForm,
manage_addNoDuplicateLogin),
#icon='www/noduplicatelogin.png',
visibility=None,
)
def initialize(context):
"""Initialize the PasswordStrength plugin."""
registerMultiPlugin(PasswordStrength.meta_type)
context.registerClass(
PasswordStrength,
permission=add_user_folders,
constructors=(manage_addPasswordStrengthForm,
manage_addPasswordStrength),
#icon='www/noduplicatelogin.png',
visibility=None,
)
def initialize(context):
"""Initializer called when used as a Zope 2 product.
This is referenced from configure.zcml. Regstrations as a "Zope 2 product"
is necessary for GenericSetup profiles to work, for example.
Here, we call the Archetypes machinery to register our content types
with Zope and the CMF.
"""
registerMultiPlugin(AuthomaticPlugin.meta_type)
context.registerClass(AuthomaticPlugin,
permission=add_user_folders,
icon=os.path.join(tpl_dir, 'authomatic.png'),
constructors=(manage_addAuthomaticPluginForm,
manage_addAuthomaticPlugin),
visibility=None)
def initialize(context):
"""Initializer called when used as a Zope 2 product.
This is referenced from configure.zcml. Regstrations as a "Zope 2 product"
is necessary for GenericSetup profiles to work, for example.
Here, we call the Archetypes machinery to register our content types
with Zope and the CMF.
"""
registerMultiPlugin(AuthomaticPlugin.meta_type)
context.registerClass(
AuthomaticPlugin,
permission=add_user_folders,
icon=os.path.join(tpl_dir, 'authomatic.png'),
constructors=(
manage_addAuthomaticPluginForm,
manage_addAuthomaticPlugin
),
visibility=None
)
def initialize(context):
"""Initializer called when used as a Zope 2 product.
"""
registerMultiPlugin(users.PoiUsersPlugin.meta_type)
context.registerClass(users.PoiUsersPlugin,
permission=add_user_folders,
icon=os.path.join(os.path.dirname(__file__),
'plugins', 'users.png'),
constructors=(users.manage_addPoiUsersPluginForm,
users.manage_addPoiUsersPlugin),
visibility=None)
registerMultiPlugin(groups.PoiGroupsPlugin.meta_type)
context.registerClass(groups.PoiGroupsPlugin,
permission=add_user_folders,
icon=os.path.join(os.path.dirname(__file__),
'plugins', 'groups.png'),
constructors=(groups.manage_addPoiGroupsPluginForm,
groups.manage_addPoiGroupsPlugin),
visibility=None)
def initialize(context):
"""Initialize the LoginLockout plugin.
Register skin directory.
"""
registerMultiPlugin(LoginLockout.meta_type)
context.registerClass(
LoginLockout,
permission=add_user_folders,
constructors=(manage_addLoginLockoutForm, manage_addLoginLockout),
icon='www/tool.gif',
visibility=None,
)
# register the custom skins directory
GLOBALS = globals()
registerDirectory('skins', GLOBALS)
# register the tool
tools = (LoginLockoutTool, )
utils.ToolInit(PROJECTNAME, icon='www/tool.gif',
tools=tools).initialize(context)
def initialize(context):
context.registerClass(
MultiPathIndex,
permission='Add Pluggable Index',
constructors=(manage_addMultiPathIndexForm, manage_addMultiPathIndex),
#icon="www/index.gif",
visibility=None)
registerMultiPlugin(AccountLocker.meta_type)
context.registerClass(AccountLocker,
permission=add_user_folders,
constructors=(manage_addAccountLockerForm, manage_addAccountLocker),
visibility=None,
)
registerMultiPlugin(Auth0.meta_type)
context.registerClass(Auth0,
permission=add_user_folders,
constructors=(manage_addAuth0, ),
visibility=None,
)
def initialize(context):
context.registerClass(
MultiPathIndex,
permission='Add Pluggable Index',
constructors=(manage_addMultiPathIndexForm, manage_addMultiPathIndex),
#icon="www/index.gif",
visibility=None)
registerMultiPlugin(AccountLocker.meta_type)
context.registerClass(
AccountLocker,
permission=add_user_folders,
constructors=(manage_addAccountLockerForm, manage_addAccountLocker),
visibility=None,
)
registerMultiPlugin(Auth0.meta_type)
context.registerClass(
Auth0,
permission=add_user_folders,
constructors=(manage_addAuth0, ),
visibility=None,
)
def initialize(context):
"""Initialize the LoginLockout plugin.
Register skin directory.
"""
registerMultiPlugin(LoginLockout.meta_type)
context.registerClass(LoginLockout,
permission=add_user_folders,
constructors=(manage_addLoginLockoutForm,
manage_addLoginLockout),
icon='www/tool.gif',
visibility=None,
)
# register the custom skins directory
GLOBALS = globals()
registerDirectory('skins', GLOBALS)
# register the tool
tools = ( LoginLockoutTool, )
utils.ToolInit(
PROJECTNAME,
icon='www/tool.gif',
tools=tools).initialize(context)
def register_pas_plugin():
try:
registerMultiPlugin(plugin.ShibbolethHelper.meta_type)
except RuntimeError:
# make refresh users happy
pass
def register_oauth_plugin():
try:
registerMultiPlugin(plugin.OauthPluginBase.meta_type)
except RuntimeError:
# make refresh users happy
pass
def register_wsse_plugin():
try:
registerMultiPlugin(plugin.WsseHelper.meta_type)
except RuntimeError:
# make refresh users happy
pass
def install_plugin(dispatcher, id, title=None, REQUEST=None):
"""
Boo yah! You need this doc string or Zope 2's publisher will drop this
method faster than you can say: "This page does not seem to exist..."
During this time you will also be wondering what is going on, until you
finally get around to deleting the ignored exceptions in /Plone/error_log,
at which point you will quickly realize you need this doc string.
"""
plugin = LoginOnlyOncePlugin(id, title)
dispatcher._setObject(plugin.getId(), plugin)
if REQUEST is not None:
REQUEST['RESPONSE'].redirect('%s/manage_workspace?manage_tabs_message='
'LoginOnlyOncePlugin+added.' % dispatcher.absolute_url())
registerMultiPlugin(LoginOnlyOncePlugin.meta_type)
def initialize(context):
template = 'manage_addPlugin'
pt = PageTemplateFile(template, globals(), __name__=template)
context.registerClass(LoginOnlyOncePlugin, permission=manage_users,
constructors=(pt, install_plugin), visibility=None, icon='loo.png')
classImplements(LoginOnlyOncePlugin, IAnonymousUserFactoryPlugin,
IAuthenticationPlugin,
IChallengePlugin, IChallengeProtocolChooser, ICredentialsResetPlugin,
ICredentialsUpdatePlugin, IExtractionPlugin, IGroupEnumerationPlugin,
IGroupsPlugin, ILoginPasswordExtractionPlugin,
ILoginPasswordHostExtractionPlugin, IPropertiesPlugin,
from AccessControl.Permissions import add_user_folders
from Products.PluggableAuthService import registerMultiPlugin
from Products.CMFCore.DirectoryView import registerDirectory
import collective.passwordhistory.patch
from collective.passwordhistory import plugin
GLOBALS = globals()
registerDirectory('skins', GLOBALS)
registerMultiPlugin(plugin.PasswordHistory.meta_type)
def initialize(context):
# Register PAS plug-in
context.registerClass(plugin.PasswordHistory,
permission = add_user_folders,
constructors = (plugin.manage_addPasswordHistoryForm,
plugin.manage_addPasswordHistory),
visibility = None)
from AccessControl.Permissions import add_user_folders
from collective.workspace import pas
from Products.PluggableAuthService import registerMultiPlugin
registerMultiPlugin(pas.WorkspaceGroupManager.meta_type)
def initialize(context):
context.registerClass(
pas.WorkspaceGroupManager,
permission=add_user_folders,
constructors=(pas.manage_addWorkspaceGroupManagerForm,
pas.addWorkspaceGroupManager),
visibility=None)
from Products.Archetypes import process_types
from Products.Archetypes.public import listTypes
from Products.PluggableAuthService import registerMultiPlugin
from config import PROJECTNAME
from plugins import ssouser
from plugins import proxy
__author__ = "Sean Chen"
__email__ = "*****@*****.**"
# try to register SsouserPlugins available in add plugin selection
# dropdown list.
try:
registerMultiPlugin(ssouser.SsouserPlugins.meta_type)
registerMultiPlugin(proxy.ProxyMultiPlugins.meta_type)
except RuntimeError:
# ignore exceptions on re-registering the plugin
pass
def initialize(context):
"""
initialization ...
"""
# initialize AT content types.
import content
content # make pyflakes happy
from AccessControl.Permissions import add_user_folders
from Products.PluggableAuthService import registerMultiPlugin
from Products.WebServerAuth.plugin import MultiPlugin
from Products.WebServerAuth.utils import wwwDirectory
from Products.WebServerAuth.zmi import manage_addWebServerAuthForm, manage_addWebServerAuth
try:
registerMultiPlugin(MultiPlugin.meta_type)
except RuntimeError:
# Don't explode upon re-registering the plugin:
pass
def initialize(context):
context.registerClass(MultiPlugin,
permission=add_user_folders,
constructors=(manage_addWebServerAuthForm,
manage_addWebServerAuth),
visibility=None,
icon='%s/multiplugin.gif' % wwwDirectory)
def register_plugin():
try:
registerMultiPlugin(plugin.OpenXChangeHelper.meta_type)
except RuntimeError:
pass
#
from AccessControl.Permissions import view
from Products.PluggableAuthService import registerMultiPlugin
from Products.ShibbolethPermissions.permissions import ShibbolethPermissionsHandler
from Products.ShibbolethPermissions import zmi
registerMultiPlugin(ShibbolethPermissionsHandler.meta_type)
shib_globals = globals() # for Extensions/Install.py
def initialize(context):
"""Intializer called when used as a Zope 2 product."""
context.registerClass(ShibbolethPermissionsHandler,
permission=view,
constructors=(zmi.manage_addShibbolethPermissionsForm,
zmi.manage_addShibbolethPermissions),
visibility=None,
icon='shibbolethlogin.gif')
def register_omega13_plugin():
try:
registerMultiPlugin(Omega13Helper.meta_type)
except RuntimeError:
# make refresh users happy
pass
def register_samlplugin_plugin():
try:
registerMultiPlugin(plugin.SAML2Plugin.meta_type)
except RuntimeError:
# make refresh users happy
pass
from AccessControl.Permissions import add_user_folders
from Products.PluggableAuthService import registerMultiPlugin
from collective.customlogin import plugin
try:
registerMultiPlugin(plugin.CustomLogin.meta_type)
except RuntimeError:
# ignore exceptions on re-registering the plugin
pass
def initialize(context):
context.registerClass(plugin.CustomLogin,
permission=add_user_folders,
constructors=(plugin.manage_addCustomLoginForm,
plugin.manage_addCustomLogin),
visibility=None,
icon="")
from Products.PluggableAuthService import registerMultiPlugin
from plugins import onetimetoken_handler
from permissions import *
from Products.GenericSetup import profile_registry
from Products.GenericSetup import EXTENSION
from Products.CMFPlone.interfaces import IPloneSiteRoot
registerMultiPlugin(onetimetoken_handler.OneTimeTokenPlugin.meta_type)
def initialize(context):
"""
"""
context.registerClass(
onetimetoken_handler.OneTimeTokenPlugin,
permission=ManageUsers,
constructors=(onetimetoken_handler.manage_addOneTimeTokenForm,
onetimetoken_handler.manage_addOneTimeTokenPlugin),
visibility=None)
""" Utilities for mayors adapt functionality """ from Products.PluggableAuthService import registerMultiPlugin import roleplugin registerMultiPlugin(roleplugin.CityMayorUserFactory.meta_type)
from AccessControl.Permissions import add_user_folders
from Products.CMFCore.utils import ToolInit
from Products.membrane.config import PROJECTNAME
from Products.membrane.plugins import usermanager, groupmanager, \
propertymanager, rolemanager, userfactory
from Products.PluggableAuthService import registerMultiPlugin
registerMultiPlugin(usermanager.MembraneUserManager.meta_type)
registerMultiPlugin(groupmanager.MembraneGroupManager.meta_type)
registerMultiPlugin(propertymanager.MembranePropertyManager.meta_type)
registerMultiPlugin(rolemanager.MembraneRoleManager.meta_type)
registerMultiPlugin(userfactory.MembraneUserFactory.meta_type)
def initialize(context):
context.registerClass(
usermanager.MembraneUserManager,
permission=add_user_folders,
constructors=(usermanager.manage_addMembraneUserManagerForm,
usermanager.addMembraneUserManager),
visibility=None
)
context.registerClass(
groupmanager.MembraneGroupManager,
permission=add_user_folders,
constructors=(groupmanager.manage_addMembraneGroupManagerForm,
from AccessControl.Permissions import add_user_folders
from collective.workspace import pas
from Products.PluggableAuthService import registerMultiPlugin
registerMultiPlugin(pas.WorkspaceGroupManager.meta_type)
def initialize(context):
context.registerClass(
pas.WorkspaceGroupManager,
permission=add_user_folders,
constructors=(pas.manage_addWorkspaceGroupManagerForm,
pas.addWorkspaceGroupManager),
visibility=None,
)
def register_aspxauthplugin_plugin():
try:
registerMultiPlugin(plugin.ASPXAuthPlugin.meta_type)
except RuntimeError:
# make refresh users happy
pass
def register_osiris_plugin():
try:
registerMultiPlugin(plugin.OsirisHelper.meta_type)
except RuntimeError:
# make refresh users happy
pass
from Products.PluggableAuthService import registerMultiPlugin
from Products.CMFCore.permissions import ManagePortal
import local_role
registerMultiPlugin(local_role.RelationshipLocalRoleManager.meta_type)
def initialize(context):
# Register our PAS plugin
context.registerClass(local_role.RelationshipLocalRoleManager,
permission = ManagePortal,
constructors = (local_role.manage_addRelationshipLocalRoleManagerForm,
local_role.manage_addRelationshipLocalRoleManager),
visibility = None)
# -*- extra stuff goes here -*-
from KerberosAuthHelper import KerberosAuthHelper
from KerberosAuthHelper import addKerberosAuthHelper
from Products.PluggableAuthService import registerMultiPlugin
from AccessControl.Permissions import manage_users as ManageUsers
registerMultiPlugin(KerberosAuthHelper.meta_type)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
context.registerClass( KerberosAuthHelper
, permission=ManageUsers
, constructors=(
KerberosAuthHelper.manage_addKerberosAuthHelperForm,
addKerberosAuthHelper, )
, visibility=None
, icon='KerberosAuthHelper.png'
)
Zope server will load this file when starts up. Initialization work
happens here.
"""
from Products.PluggableAuthService import registerMultiPlugin
from plugins import challenge
from plugins import squirrel
__author__ = "Sean Chen"
__email__ = "*****@*****.**"
# try to register RedirectChallenge available in add plugin selection
# dropdown list.
try:
registerMultiPlugin(challenge.RedirectChallenge.meta_type)
registerMultiPlugin(squirrel.SquirrelPlugins.meta_type)
except RuntimeError:
# ignore exceptions on re-registering the plugin
pass
# Zope server will load this method when starts up.
def initialize(context):
"""
Initializer called when used as a Zope 2 product.
"""
context.registerClass(challenge.RedirectChallenge,
constructors=(
challenge.manage_addRedirectChallengeForm,
# -*- coding: utf-8 -*-
# Copyright (c) 2011 Infrae. All rights reserved.
# See also LICENSE.txt
# $Id$
from AccessControl.Permissions import manage_users as ManageUsers
from Products.PluggableAuthService import registerMultiPlugin
from silva.pas.kerberos5.plugins import kerberos5
registerMultiPlugin(kerberos5.Kerberos5Plugin.meta_type)
def initialize(context):
context.registerClass(kerberos5.Kerberos5Plugin,
permission=ManageUsers,
constructors=
(kerberos5.manage_addKerberos5PluginForm,
kerberos5.manage_addKerberos5Plugin),
visibility=None,
icon="www/kerberos5.png")
# -*- coding: utf-8 -*-
from AccessControl.Permissions import add_user_folders
from borg.localrole import workspace
from Products.PluggableAuthService import registerMultiPlugin
registerMultiPlugin(workspace.WorkspaceLocalRoleManager.meta_type)
def initialize(context):
# Register PAS plug-in
context.registerClass(
workspace.WorkspaceLocalRoleManager,
permission=add_user_folders,
constructors=(
workspace.manage_addWorkspaceLocalRoleManagerForm,
workspace.manage_addWorkspaceLocalRoleManager,
),
visibility=None
)
# -*- coding: utf-8 -*-
from zope.i18nmessageid import MessageFactory
from AccessControl.Permissions import add_user_folders
from Products.PluggableAuthService import registerMultiPlugin
from redomino.tokenrole.config import PROJECTNAME
from redomino.tokenrole.plugins import tokenrole
registerMultiPlugin(tokenrole.TokenRole.meta_type)
tokenroleMessageFactory = MessageFactory(PROJECTNAME)
def initialize(context):
context.registerClass(tokenrole.TokenRole,
permission=add_user_folders,
constructors=(tokenrole.manage_addTokenRoleForm,
tokenrole.addTokenRole),
visibility=None)
from AccessControl.Permissions import add_user_folders
from Products.PluggableAuthService import registerMultiPlugin
from Products.AngelPas.plugin import MultiPlugin
from Products.AngelPas.utils import www_directory
from Products.AngelPas.zmi import manage_addAngelPasForm, manage_addAngelPas
try:
registerMultiPlugin(MultiPlugin.meta_type)
except RuntimeError:
# Don't explode upon re-registering the plugin:
pass
def initialize(context):
context.registerClass(MultiPlugin,
permission=add_user_folders,
constructors=(manage_addAngelPasForm,
manage_addAngelPas),
visibility=None,
icon='%s/multiplugin.gif' % www_directory
)
def register_mxit_plugin():
try:
registerMultiPlugin(plugin.MXitHelper.meta_type)
except RuntimeError:
# make refresh users happy
pass
def register_inwimandant_plugin():
registerMultiPlugin(plugin.InwiMandant.meta_type)
from zope.i18nmessageid import MessageFactory
from AccessControl.Permissions import add_user_folders
from Products.PluggableAuthService import registerMultiPlugin
from redomino.tokenrole.config import PROJECTNAME
tokenroleMessageFactory = MessageFactory(PROJECTNAME)
from redomino.tokenrole.plugins import tokenrole
registerMultiPlugin(tokenrole.TokenRole.meta_type)
def initialize(context):
context.registerClass(tokenrole.TokenRole,
permission=add_user_folders,
constructors=(tokenrole.manage_addTokenRoleForm,
tokenrole.addTokenRole),
visibility=None)
# -*- coding: utf-8 -*-
from AccessControl.Permissions import add_user_folders
from collective.lemonldap import pas
from Products.PluggableAuthService import registerMultiPlugin
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('collective.lemonldap')
registerMultiPlugin(pas.LemonLDAPManager)
def initialize(context):
context.registerClass(pas.LemonLDAPManager,
permission=add_user_folders,
constructors=(pas.manage_addLemonLDAPManagerForm,
pas.manage_addLemonLDAPManager),
visibility=None,
icon='')
def register_pas_plugin():
try:
registerMultiPlugin(plugin.ShibbolethHelper.meta_type)
except RuntimeError:
# make refresh users happy
pass
# -*- coding: utf-8 -*-
# Copyright (c) 2011 Infrae. All rights reserved.
# See also LICENSE.txt
# $Id$
from AccessControl.Permissions import manage_users as ManageUsers
from Products.PluggableAuthService import registerMultiPlugin
from silva.pas.kerberos5.plugins import kerberos5
registerMultiPlugin(kerberos5.Kerberos5Plugin.meta_type)
def initialize(context):
context.registerClass(
kerberos5.Kerberos5Plugin,
permission=ManageUsers,
constructors=(kerberos5.manage_addKerberos5PluginForm,
kerberos5.manage_addKerberos5Plugin),
visibility=None,
icon="www/kerberos5.png")
from Products.PluggableAuthService import registerMultiPlugin
from AccessControl.Permissions import add_user_folders
from borg.localrole import workspace
registerMultiPlugin(workspace.WorkspaceLocalRoleManager.meta_type)
def initialize(context):
# Register PAS plug-in
context.registerClass(workspace.WorkspaceLocalRoleManager,
permission=add_user_folders,
constructors=(workspace.manage_addWorkspaceLocalRoleManagerForm,
workspace.manage_addWorkspaceLocalRoleManager),
visibility=None)
def register_pas_plugin():
try:
registerMultiPlugin(plugin.RememberEmailAuth.meta_type)
except RuntimeError:
# make refresh users happy
pass
def register_preauth_plugin():
try:
registerMultiPlugin(plugin.OwncloudHelper.meta_type)
except RuntimeError:
# make refresh users happy
pass
def register_memberapproval_plugin():
try:
registerMultiPlugin(plugin.MemberapprovalPlugin.meta_type)
except RuntimeError:
# make refresh users happy
pass
from AccessControl.Permissions import manage_users as ManageUsers
from .plugins import *
from Products.PluggableAuthService import registerMultiPlugin
registerMultiPlugin('Password File User & Role Manager')
def initialize(context):
context.registerClass(PasswordFileUserRoleManager,
permission=ManageUsers,
constructors=(
manage_addPasswordFileUserRoleManagerForm,
addPasswordFileUserRoleManager,
),
icon='www/icon.gif')
from setup import RhaptosSitePolicy
this_module = sys.modules[ __name__ ]
# we have an EPS in our skins, and must teach FSDV how to treat it
from Products.CMFCore.DirectoryView import registerFileExtension
from Products.CMFCore.FSFile import FSFile
registerFileExtension('eps', FSFile)
from Products.PluggableAuthService import registerMultiPlugin
from Products.PluggableAuthService.permissions import ManageUsers
import pas.AltHashAuth as AHA
from AccessControl import allow_module
registerMultiPlugin(AHA.AltHashAuth.meta_type)
# Make the skins available as DirectoryViews
registerDirectory('skins', globals())
def initialize(context):
RhaptosSitePolicy.register(context, product_globals)
RhaptosSite.register(context, product_globals)
profile_registry.registerProfile('rhaptos-default',
'RhaptosSite',
'Extension profile for a RhaptosSite',
'profiles/default',
'RhaptosSite',
EXTENSION,
for_=IPloneSiteRoot)
#
from AccessControl.Permissions import add_user_folders
from Products.PluggableAuthService import registerMultiPlugin
from Products.AutoUserMakerPASPlugin.auth import ApacheAuthPluginHandler
from Products.AutoUserMakerPASPlugin import zmi
registerMultiPlugin(ApacheAuthPluginHandler.meta_type)
def initialize(context):
"""Intializer called when used as a Zope 2 product."""
context.registerClass(ApacheAuthPluginHandler,
permission=add_user_folders,
constructors=(zmi.manage_addAutoUserMakerForm,
zmi.manage_addAutoUserMaker),
visibility=None,
icon='autousermaker.gif')
def register_package_plugin():
try:
registerMultiPlugin(plugin.PackagePlugin.meta_type)
except RuntimeError:
# make refresh users happy
pass
#################################
# pas monkies 2 play w/ gruf
if config.PAS_INSIDE_GRUF:
import gruf_support
#################################
# new groups tool
from tools.membership import MembershipTool
from tools.memberdata import MemberDataTool
from tools.groups import GroupsTool
from tools.groupdata import GroupDataTool
#################################
# register plugins with pas
try:
registerMultiPlugin(user.UserManager.meta_type)
registerMultiPlugin(group.GroupManager.meta_type)
registerMultiPlugin(role.GroupAwareRoleManager.meta_type)
registerMultiPlugin(local_role.LocalRolesManager.meta_type)
registerMultiPlugin(ufactory.PloneUserFactory.meta_type)
registerMultiPlugin(property.ZODBMutablePropertyProvider.meta_type)
registerMultiPlugin(crumbler.CookieCrumblingPlugin.meta_type)
registerMultiPlugin(cookie_handler.ExtendedCookieAuthHelper.meta_type)
registerMultiPlugin(autogroup.AutoGroup.meta_type)
registerMultiPlugin( passwordpolicy.PasswordPolicyPlugin.meta_type )
except RuntimeError:
# make refresh users happy
pass
def initialize(context):
def register_package_plugin():
try:
registerMultiPlugin(plugin.PackagePlugin.meta_type)
except RuntimeError:
# make refresh users happy
pass
# -*- coding: utf-8 -*-
from Products.PluggableAuthService import registerMultiPlugin
from AccessControl.Permissions import add_user_folders
from pas.plugins.shibboleth import group, property, enumeration, role
registerMultiPlugin(group.ShibGroupManager.meta_type)
registerMultiPlugin(property.ShibUserPropertiesManager.meta_type)
registerMultiPlugin(enumeration.ShibUserEnumerationManager.meta_type)
registerMultiPlugin(role.ShibRoleManager.meta_type)
def initialize(context):
context.registerClass(group.ShibGroupManager,
permission=add_user_folders,
constructors=(
group.manage_addShibGroupManagerForm,
group.manage_addShibGroupManager),
visibility=None,
icon='')
context.registerClass(property.ShibUserPropertiesManager,
permission=add_user_folders,
constructors=(
property.manage_addShibUserPropertiesManagerForm,
property.manage_addShibUserProperties),
visibility=None,
icon='')
context.registerClass(enumeration.ShibUserEnumerationManager,
permission=add_user_folders,
constructors=(
enumeration.manage_addShibUserEnumerationManagerForm, # NOQA
