def setup(app, path):
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, OmnipotentUser().__of__(app.acl_users))
site = app.unrestrictedTraverse(path)
populateFolder(site, 'Folder', 'Document')
return site
def main(app):
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, EvenMoreOmnipotentUser().__of__(app.acl_users))
app = makerequest(app)
deCNX(app.plone)
transaction.commit()
def main(app):
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, EvenMoreOmnipotentUser().__of__(app.acl_users))
app = makerequest(app)
# Grab connection to db
db = app.plone.objectValues('Z Psycopg 2 Database Connection')[0]()
# Get all users who have extended roles
updates = 0
passwds = app.plone.acl_users.source_users._user_passwords
for mid in passwds.keys():
mem = app.plone.portal_membership.getMemberById(mid)
roles = [
role for role in mem.getRoles()
if role not in ['Member', 'Authenticated']
]
if roles != []:
passwd = passwds[mid]
db.query(
"update persons set passwd = %s, groups = %s"
" where personid = %s",
query_data=(passwd, roles, mid))
print mid, roles
updates += 1
if updates % 10 == 0:
transaction.commit()
transaction.commit()
def main(app):
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, EvenMoreOmnipotentUser().__of__(app.acl_users))
app = makerequest(app)
# Reindex content catalog
catalog = app.plone.content.catalog
catalog.refreshCatalog(clear=1)
# Reindex lenses catalog
catalog = app.plone.lens_catalog
catalog.refreshCatalog(clear=1)
# clear hit count
htool = app.plone.portal_hitcount
htool.resetHitCounts()
###FIXME resetHitCounts is currently broken: remove this when fixed
objs = app.plone.content.objectValues(
['Version Folder', 'Module Version Folder'])
for ob in objs:
try:
htool.registerObject(ob.id, ob.latest.created)
except IndexError:
# Bad object in content
pass
transaction.commit()
def main(app, data_dir):
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, EvenMoreOmnipotentUser().__of__(app.acl_users))
app = makerequest(app)
#uninstallProducts(app.plone)
logger.info('Generating collections list')
generateCollectionsList(app.plone, data_dir)
logger.info('Generating modules list')
generateModulesList(app.plone, data_dir)
logger.info('Deleting groups')
cleanoutGroups(app.plone, data_dir)
transaction.savepoint(optimistic=True)
logger.info('Deleting lenses')
cleanoutLenses(app.plone, data_dir)
transaction.savepoint(optimistic=True)
logger.info('Deleting content')
cleanoutRhaptosContent(app.plone, data_dir)
transaction.savepoint(optimistic=True)
logger.info('Deleting users')
cleanoutUsers(app.plone, data_dir)
transaction.savepoint(optimistic=True)
postCleanoutPopularity(app.plone, data_dir)
transaction.savepoint(optimistic=True)
app.plone.portal_catalog.refreshCatalog(clear=1)
transaction.commit()
def main(app, id, title, dbauser, dbuser, dbname, dbserver, dbport):
_policy=PermissiveSecurityPolicy()
_oldpolicy=setSecurityPolicy(_policy)
newSecurityManager(None, EvenMoreOmnipotentUser().__of__(app.acl_users))
app = makerequest(app)
# Add Rhaptos Site
factory = app.manage_addProduct['RhaptosSite']
factory.manage_addRhaptosSite(id,
title=title, description='',
dbauser=dbauser,
dbapass=None,
dbuser=dbuser,
dbpass=None,
dbname=dbname,
dbserver=dbserver,
dbport=dbport and int(dbport) or None)
# Add Virtual Host Entry
app.virtual_hosting.set_map('http://*.cnx.rice.edu/ /'+id+'\nhttp://localhost/ /'+id)
# Apply cnx.org styles
site = getattr(app, id)
site.portal_setup.setImportContext(
'profile-Products.CNXPloneSite:default')
site.portal_setup.manage_importSelectedSteps(
['cnx_install'],
True, # run_dependencies
app.REQUEST.RESPONSE)
transaction.commit()
def spoofRequest(app):
user = app.acl_users.getUserById("admin")
if not user:
user = OmnipotentUser().__of__(app.acl_users)
_policy = PermissiveSecurityPolicy()
setSecurityPolicy(_policy)
newSecurityManager(None, user)
return makerequest(app, environ=os.environ)
def spoofRequest(app):
"""
Make REQUEST variable to be available on the Zope application server.
This allows acquisition to work properly
"""
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, OmnipotentUser().__of__(app.acl_users))
return makerequest(app)
def main():
global app
attr_storage = AttributeStorage()
fss_storage = FileSystemStorage()
app = makerequest(app)
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, OmnipotentUser().__of__(app.acl_users))
global portal, ct
portal = app[ploneid]
setSite(portal)
# Initialization
log('Initialized at', datetime.now().isoformat())
ct = getToolByName(portal, 'portal_catalog')
fssfiles = ct.searchResults({'portal_type': pt})
for fssfile in fssfiles:
log('Migrating: [%s] %s in %s ... ' %
(fssfile.portal_type, fssfile.id, fssfile.getPath()))
obj = portal.restrictedTraverse(fssfile.getPath())
try:
f_tp = 'image'
field = obj.Schema()[f_tp]
except KeyError, e:
f_tp = 'file'
field = obj.Schema()[f_tp]
fieldstorage = field.storage
try:
mimetype = field.getContentType(obj)
except:
mimetype = obj.getContentType()
content = StringIO(str(fss_storage.get(f_tp, obj)))
# Cleaning the storage
fss_storage.unset(f_tp, obj)
field.set(obj, content)
field.setContentType(obj, mimetype)
field.setFilename(obj, obj.id)
log('Transaction commit and Data.fs synchronism.')
transaction.commit()
app._p_jar.sync()
def __init__(self):
"""
"""
app = makerequest(app)
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
self.site = app[ploneid]
setSite(self.site)
newSecurityManager(None, OmnipotentUser().__of__(app.acl_users))
self.catalog = getToolByName(site, 'portal_catalog')
self.searchfiles = self.catalog.searchResults(portal_type='File')
def main(app, connection_string):
_policy=PermissiveSecurityPolicy()
_oldpolicy=setSecurityPolicy(_policy)
newSecurityManager(None, EvenMoreOmnipotentUser().__of__(app.acl_users))
app = makerequest(app)
try:
da = app.devrep
except: # If server is down, try again, only throws one error
da = app.devrep
da.connection_string = connection_string
transaction.commit()
print "Connected %s to '%s'" % (da.connected(), da.connection_string)
def _make_permissive(self):
"""
Make a permissive security manager with all rights. Hell,
we're developers, aren't we? Security is for whimps. :)
"""
from Products.CMFCore.tests.base.security import PermissiveSecurityPolicy
import AccessControl
from AccessControl.SecurityManagement import newSecurityManager
from AccessControl.SecurityManager import setSecurityPolicy
_policy = PermissiveSecurityPolicy()
self.oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, AccessControl.User.system)
def spoofRequest(app):
"""
Make REQUEST variable to be available on the Zope application server.
This allows acquisition to work properly
"""
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, OmnipotentUser().__of__(app.acl_users))
info = {
'SERVER_NAME': 'isaw4.atlantides.org',
'SERVER_PORT': '8083',
'REQUEST_METHOD': 'GET'
}
return makerequest(app, environ=info)
def main(app, license_url, workspaces=None):
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, EvenMoreOmnipotentUser().__of__(app.acl_users))
app = makerequest(app)
for wgname in workspaces:
wg = app.plone.GroupWorkspaces[wgname]
print wgname
for m in wg.objectValues():
if m.state == 'published':
print 'Skipping published: ', m.id
else:
print ' ', m.id
m.license = license_url
transaction.commit()
def main(app, connection_string):
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, EvenMoreOmnipotentUser().__of__(app.acl_users))
app = makerequest(app)
da = app.devrep
retry = -1
while retry < 0:
try:
da.edit(da.title,
connection_string,
da.zdatetime,
check=True,
tilevel=da.tilevel,
encoding=da.encoding,
ustrings=da.ustrings)
break
except:
# First time failing. Trying to use old cnx_str
retry += 1
transaction.commit()
transaction.commit()
def spoofRequest(app):
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, OmnipotentUser().__of__(app.acl_users))
return makerequest(app)
from AccessControl.SecurityManager import setSecurityPolicy
from Products.CMFCore.tests.base.security import PermissiveSecurityPolicy
from Products.CMFCore.tests.base.security import OmnipotentUser
from Products.CMFCore.utils import getToolByName
from zope.app.component.hooks import setSite
from Acquisition import aq_base
from datetime import datetime
from AccessControl.SecurityManagement import noSecurityManager
attr_storage = AttributeStorage()
ploneid = 'essintra'
pt = ('File', )
app = makerequest(app)
_policy = PermissiveSecurityPolicy()
_oldpolicy = setSecurityPolicy(_policy)
newSecurityManager(None, OmnipotentUser().__of__(app.acl_users))
portal = app[ploneid]
setSite(portal)
print 'Iniciado as ',
print datetime.now().isoformat()
ct = getToolByName(portal, 'portal_catalog')
arquivos = ct.searchResults({'portal_type': pt})
for arq in arquivos:
print 'Populando: %s em %s ... ' % (arq.id, arq.getPath()),
obj = portal.restrictedTraverse(arq.getPath())
def setUp(self):
TransactionalTest.setUp(self)
self._policy = PermissiveSecurityPolicy()
self._oldPolicy = setSecurityPolicy(self._policy)
newSecurityManager(None, AnonymousUser().__of__(self.app.acl_users))
def spoofRequest(app):
_policy = PermissiveSecurityPolicy()
setSecurityPolicy(_policy)
user = app.acl_users.getUser('admin')
newSecurityManager(None, user.__of__(app.acl_users))
return makerequest(app)
