def populateDefaultUsers():
userService = support.entityFor(IUserService)
assert isinstance(userService, IUserService)
userRbacService = support.entityFor(IUserRbacService)
assert isinstance(userRbacService, IUserRbacService)
users = userService.getAll(limit=1, q=QUser(name='Janet'))
if not users:
user = User()
user.FirstName = 'Janet'
user.LastName = 'Editor'
user.EMail = '*****@*****.**'
user.Name = 'admin'
user.Password = hashlib.sha512(b'a').hexdigest()
user.Id = userService.insert(user)
else:
user = next(iter(users))
userRbacService.assignRole(user.Id, blogRoleAdministratorId())
for name in (('Andrew', 'Reporter'), ('Christine', 'Journalist')):
users = userService.getAll(limit=1, q=QUser(name=name[0]))
if not users:
user = User()
user.FirstName = name[0]
user.LastName = name[1]
user.EMail = '*****@*****.**' % name
user.Name = name[1].lower()
user.Password = hashlib.sha512(b'a').hexdigest()
user.Id = userService.insert(user)
else:
user = next(iter(users))
userRbacService.assignRole(user.Id, blogRoleCollaboratorId())
def populateDefaultUsers():
userService = support.entityFor(IUserService)
assert isinstance(userService, IUserService)
userRbacService = support.entityFor(IUserRbacService)
assert isinstance(userRbacService, IUserRbacService)
users = userService.getAll(limit=1, q=QUser(name='admin'))
if not users:
user = User()
user.FirstName = 'Janet'
user.LastName = 'Editor'
user.EMail = '*****@*****.**'
user.Name = 'admin'
user.Password = hashlib.sha512(b'a').hexdigest()
user.Id = userService.insert(user)
else: user = next(iter(users))
userRbacService.assignRole(user.Id, blogRoleAdministratorId())
for name in (('Andrew', 'Reporter'), ('Christine', 'Journalist')):
loginName = name[1].lower()
users = userService.getAll(limit=1, q=QUser(name=loginName))
if not users:
user = User()
user.FirstName = name[0]
user.LastName = name[1]
user.EMail = '*****@*****.**' % name
user.Name = loginName
user.Password = hashlib.sha512(b'a').hexdigest()
user.Id = userService.insert(user)
else: user = next(iter(users))
userRbacService.assignRole(user.Id, blogRoleCollaboratorId())
def createArticles():
artService = entityFor(IArticleService)
slug = 'article-demo'
#assert isinstance(artService, ArticleServiceAlchemy)
try:
artService.getBySlug(slug)
return
# session.query(ArticleMapped.Id).filter(ArticleMapped.Id == '1').one()[0]
except (NoResultFound, InputError):
theArticle = ArticleMapped()
theArticle.CreatedOn = current_timestamp()
theArticle.Slug = slug
artService.insert(theArticle)
artCtxService = entityFor(IArticleCtxService)
assert isinstance(artCtxService, ArticleCtxServiceAlchemy)
for typ in [1,2,3,4]:
ctx = ArticleCtxMapped()
ctx.Type = typ
ctx.Content = DATA['article_content']
ctx.Article = theArticle.Id
artCtxService.insert(ctx)
def createArticles():
artService = entityFor(IArticleService)
slug = 'article-demo'
#assert isinstance(artService, ArticleServiceAlchemy)
try:
artService.getBySlug(slug)
return
# session.query(ArticleMapped.Id).filter(ArticleMapped.Id == '1').one()[0]
except (NoResultFound, InputError):
theArticle = ArticleMapped()
theArticle.CreatedOn = current_timestamp()
theArticle.Slug = slug
artService.insert(theArticle)
artCtxService = entityFor(IArticleCtxService)
assert isinstance(artCtxService, ArticleCtxServiceAlchemy)
for typ in [1, 2, 3, 4]:
ctx = ArticleCtxMapped()
ctx.Type = typ
ctx.Content = DATA['article_content']
ctx.Article = theArticle.Id
artCtxService.insert(ctx)
def populateBlogAdministratorRole():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
rightService = support.entityFor(IRightService)
assert isinstance(rightService, IRightService)
for right in rightService.getAll():
assert isinstance(right, Right)
roleService.assignRight(blogRoleAdministratorId(), right.Id)
roleService.assignRole(rootRoleId(), blogRoleAdministratorId())
def populateCollaboratorRole():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
rightService = support.entityFor(IRightService)
assert isinstance(rightService, IRightService)
roleService.assignRight(blogRoleCollaboratorId(), rightService.getByName(aclType().name, rightLivedeskView().name).Id)
roleService.assignRight(blogRoleCollaboratorId(), rightService.getByName(aclType().name, rightManageOwnPost().name).Id)
roleService.assignRight(blogRoleCollaboratorId(), rightService.getByName(aclType().name, rightMediaArchiveView().name).Id)
roleService.assignRole(blogRoleAdministratorId(), blogRoleCollaboratorId())
def populateRootUser():
userService = support.entityFor(IUserService)
assert isinstance(userService, IUserService)
userRbacService = support.entityFor(IUserRbacService)
assert isinstance(userRbacService, IUserRbacService)
users = userService.getAll(limit=1, q=QUser(name='Janet'))
if not users:
user = User()
user.Name = 'root'
user.Password = hashlib.sha512(b'root').hexdigest()
user.Id = userService.insert(user)
else: user = users[0]
userRbacService.assignRole(user.Id, rootRoleId())
def populateBlogAdministratorRole():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
rightService = support.entityFor(IRightService)
assert isinstance(rightService, IRightService)
for right in rightService.getAll():
assert isinstance(right, Right)
if right.Name == rightRequestsInspection().name: continue
roleService.assignRight(blogRoleAdministratorId(), right.Id)
roleService.assignRole(rootRoleId(), blogRoleAdministratorId())
q = QRight()
q.name = rightRequestsInspection().name
for right in rightService.getAll(q=q):
assert isinstance(right, Right)
roleService.assignRight(rootRoleId(), right.Id)
def populateBlogAdministratorRole():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
rightService = support.entityFor(IRightService)
assert isinstance(rightService, IRightService)
for right in rightService.getAll():
assert isinstance(right, Right)
if right.Name == rightRequestsInspection().name: continue
roleService.assignRight(blogRoleAdministratorId(), right.Id)
roleService.assignRole(rootRoleId(), blogRoleAdministratorId())
q = QRight()
q.name = rightRequestsInspection().name
for right in rightService.getAll(q=q):
assert isinstance(right, Right)
roleService.assignRight(rootRoleId(), right.Id)
def deploy():
loadPlugins()
if not os.path.isfile(configurations_file_path()):
print('The configuration file "%s" doesn\'t exist, create one by running the the application '
'with "-dump" option' % configurations_file_path())
sys.exit(1)
with open(configurations_file_path(), 'r') as f: config = load(f)
PACKAGE_EXTENDER.addFreezedPackage('__plugin__.')
pluginModules = aop.modulesIn('__plugin__.**')
for module in pluginModules.load().asList():
if not isPackage(module) and re.match('__plugin__\\.[^\\.]+$', module.__name__):
raise SetupError('The plugin setup module %r is not allowed directly in the __plugin__ package it needs '
'to be in a sub package' % module.__name__)
assembly = ioc.open(pluginModules, config=config)
try:
assembly.processStart()
from __plugin__.plugin.registry import services
services = services()
finally: ioc.deactivate()
try: import application
except ImportError: raise SetupError('Cannot access the application module')
resourcesRegister = entityFor(IResourcesRegister, application.assembly)
assert isinstance(resourcesRegister, IResourcesRegister), 'There is no resource register for the services'
assert log.debug('Registered REST services:\n\t%s', '\n\t'.join(str(srv) for srv in services)) or True
for service in services:
resourcesRegister.register(service)
def fullAccessIPs():
if not options.isFlag(FLAG_FULL_IP): return
serviceGateway = entityFor(IGatewayService)
assert isinstance(serviceGateway, IGatewayService)
if options.addIPs:
for ip in options.addIPs:
gateway = Custom()
gateway.Name = 'full_access_%s' % ip
gateway.Clients = [
'\.'.join(mark.replace('*', '\d+') for mark in ip.split('.'))
]
try:
serviceGateway.insert(gateway)
except:
log.info('IP \'%s\' already present', ip)
else:
log.info('IP \'%s\' added', ip)
if options.remIPs:
for ip in options.remIPs:
if serviceGateway.delete('full_access_%s' % ip):
log.info('IP \'%s\' removed', ip)
else:
log.info('IP \'%s\' is not present', ip)
def populateVersionConfig():
creator = alchemySessionCreator()
session = creator()
assert isinstance(session, Session)
generalSettingService = support.entityFor(IGeneralSettingService)
assert isinstance(generalSettingService, IGeneralSettingService)
generalSetting = GeneralSetting()
generalSetting.Group = "version"
if session.query(GeneralSettingMapped).filter(GeneralSettingMapped.Key == "major").count() == 0:
generalSetting.Key = "major"
generalSetting.Value = "1"
generalSettingService.insert(generalSetting)
if session.query(GeneralSettingMapped).filter(GeneralSettingMapped.Key == "minor").count() == 0:
generalSetting.Key = "minor"
generalSetting.Value = "6"
generalSettingService.insert(1, generalSetting)
if session.query(GeneralSettingMapped).filter(GeneralSettingMapped.Key == "revision").count() == 0:
generalSetting.Key = "revision"
generalSetting.Value = "0"
generalSettingService.insert(1, generalSetting)
def followWiring():
from ally.container.support import entityFor
wiring = Wiring.wiringOf(value.__class__)
if wiring:
assert isinstance(wiring,
Wiring), 'Invalid wiring %s' % wiring
for wentity in wiring.entities:
assert isinstance(wentity, WireEntity)
if wentity.name not in value.__dict__:
try:
setattr(value, wentity.name,
entityFor(wentity.type, wentity.name))
except:
raise SetupError(
'Cannot solve wiring \'%s\' at: %s' %
(wentity.name,
locationStack(value.__class__)))
mapping = wirings.get(wiring)
if mapping:
assert isinstance(mapping,
dict), 'Invalid mapping %s' % mapping
for wconfig in wiring.configurations:
assert isinstance(wconfig, WireConfig)
if wconfig.name not in value.__dict__:
name = mapping.get(wconfig.name)
if name is not None:
setattr(value, wconfig.name,
assembly.processForName(name))
if followUp: followUp()
def userServiceUpdate():
class AutoRolesProxy(IProxyHandler):
''' Automatically assign roles to new created users.'''
def __init__(self, userRbacService):
self.userRbacService = userRbacService
def handle(self, execution):
userId = execution.invoke()
self.userRbacService.addRole(userId, 'Admin')
return userId
userService = support.entityFor(IUserService)
handler = AutoRolesProxy(support.entityFor(IUserRbacService))
handler = ProxyFilter(handler, 'insert')
registerProxyHandler(handler, userService)
def populateVersionConfig():
creator = alchemySessionCreator()
session = creator()
assert isinstance(session, Session)
generalSettingService = support.entityFor(IGeneralSettingService)
assert isinstance(generalSettingService, IGeneralSettingService)
generalSetting = GeneralSetting()
generalSetting.Group = 'version'
if session.query(GeneralSettingMapped).filter(GeneralSettingMapped.Key == 'major').count() == 0:
generalSetting.Key = 'major'
generalSetting.Value = '1'
generalSettingService.insert(generalSetting)
if session.query(GeneralSettingMapped).filter(GeneralSettingMapped.Key == 'minor').count() == 0:
generalSetting.Key = 'minor'
generalSetting.Value = '6'
generalSettingService.insert(generalSetting)
if session.query(GeneralSettingMapped).filter(GeneralSettingMapped.Key == 'revision').count() == 0:
generalSetting.Key = 'revision'
generalSetting.Value = '0'
generalSettingService.insert(generalSetting)
def populateVersionConfig():
creator = alchemySessionCreator()
session = creator()
assert isinstance(session, Session)
generalSettingService = support.entityFor(IGeneralSettingService)
assert isinstance(generalSettingService, IGeneralSettingService)
generalSetting = GeneralSetting()
generalSetting.Group = 'version'
if session.query(GeneralSettingMapped).filter(
GeneralSettingMapped.Key == 'major').count() == 0:
generalSetting.Key = 'major'
generalSetting.Value = '1'
generalSettingService.insert(generalSetting)
if session.query(GeneralSettingMapped).filter(
GeneralSettingMapped.Key == 'minor').count() == 0:
generalSetting.Key = 'minor'
generalSetting.Value = '6'
generalSettingService.insert(generalSetting)
if session.query(GeneralSettingMapped).filter(
GeneralSettingMapped.Key == 'revision').count() == 0:
generalSetting.Key = 'revision'
generalSetting.Value = '0'
generalSettingService.insert(generalSetting)
def populateCollaboratorRole():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roleService.assignRight(blogRoleCollaboratorId(), rightId(rightLivedeskView()))
roleService.assignRight(blogRoleCollaboratorId(), rightId(rightManageOwnPost()))
roleService.assignRight(blogRoleCollaboratorId(), rightId(rightMediaArchiveView()))
roleService.assignRight(blogRoleCollaboratorId(), rightId(rightMediaArchiveUpload()))
roleService.assignRole(blogRoleAdministratorId(), blogRoleCollaboratorId())
def populateCollaboratorRole():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roleService.assignRight(blogRoleCollaboratorId(), rightId(rightLivedeskView()))
roleService.assignRight(blogRoleCollaboratorId(), rightId(rightManageOwnPost()))
roleService.assignRight(blogRoleCollaboratorId(), rightId(rightMediaArchiveView()))
roleService.assignRight(blogRoleCollaboratorId(), rightId(rightMediaArchiveUpload()))
roleService.assignRole(blogRoleAdministratorId(), blogRoleCollaboratorId())
def populateDefaulyGateways():
serviceGateway = entityFor(IGatewayService)
assert isinstance(serviceGateway, IGatewayService)
for data in defaultGateways():
custom = copyContainer(data, Custom())
assert isinstance(custom, Custom)
try: serviceGateway.insert(custom)
except InputError: log.info('Gateway \'%s\' already exists' % custom.Name)
def populateRootUser():
userService = support.entityFor(IUserService)
assert isinstance(userService, IUserService)
userRbacService = support.entityFor(IUserRbacService)
assert isinstance(userRbacService, IUserRbacService)
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
users = userService.getAll(limit=1, q=QUser(name='root'))
if not users:
user = User()
user.Name = 'root'
user.Password = hashlib.sha512(b'root').hexdigest()
user.Id = userService.insert(user)
else:
user = users[0]
userRbacService.assignRole(user.Id, roleService.getByName(NAME_ROOT).Id)
def insertSource(name):
sourcesService = entityFor(ISourceService)
assert isinstance(sourcesService, ISourceService)
srcs = sourcesService.getAll(q=QSource(name=name))
if srcs: src = next(iter(srcs)).Id
else:
src = Source()
src.Name = name
src.IsModifiable, src.URI, src.Type, src.Key = False, '', '', ''
src = sourcesService.insert(src)
collaboratorService = entityFor(ICollaboratorService)
assert isinstance(collaboratorService, ICollaboratorService)
colls = collaboratorService.getAll(qs=QSource(name=name))
if not colls:
coll = Collaborator()
coll.User = None
coll.Source = src
collaboratorService.insert(coll)
def createBlogAdmins():
blogAdminService = entityFor(IBlogAdminService)
assert isinstance(blogAdminService, IBlogAdminService)
for name, blog in BLOG_ADMINS.items():
blogId, userId = getBlogsIds()[blog], getUsersIds()[name]
blgs = blogAdminService.getAll(blogId)
for blg in blgs:
if blg.Id == userId: break
else:
blogAdminService.addAdmin(blogId, userId)
def createBlogAdmins():
blogAdminService = entityFor(IBlogAdminService)
assert isinstance(blogAdminService, IBlogAdminService)
for name, blog in BLOG_ADMINS.items():
blogId, userId = getBlogsIds()[blog], getUsersIds()[name]
blgs = blogAdminService.getAll(blogId)
for blg in blgs:
if blg.Id == userId: break
else:
blogAdminService.addAdmin(blogId, userId)
def getLanguagesIds():
languageService = entityFor(ILanguageService)
assert isinstance(languageService, ILanguageService)
languages = { lang.Code: lang.Id for lang in languageService.getAll() }
for code in LANGUAGES:
if code not in languages:
lang = LanguageEntity()
lang.Code = code
languages[code] = languageService.insert(lang)
return languages
def insertSource(name):
sourcesService = entityFor(ISourceService)
assert isinstance(sourcesService, ISourceService)
srcs = sourcesService.getAll(q=QSource(name=name))
if srcs: src = next(iter(srcs)).Id
else:
src = Source()
src.Name = name
src.IsModifiable, src.URI, src.Type, src.Key = False, '', '', ''
src = sourcesService.insert(src)
collaboratorService = entityFor(ICollaboratorService)
assert isinstance(collaboratorService, ICollaboratorService)
colls = collaboratorService.getAll(qs=QSource(name=name))
if not colls:
coll = Collaborator()
coll.User = None
coll.Source = src
collaboratorService.insert(coll)
def createBlogCollaborators():
blogCollaboratorService = entityFor(IBlogCollaboratorService)
assert isinstance(blogCollaboratorService, IBlogCollaboratorService)
for name, blog in BLOG_COLLABORATORS.items():
blogId, collId = getBlogsIds()[blog], getCollaboratorsIds()[name]
blgs = blogCollaboratorService.getAll(blogId)
for blg in blgs:
if blg.Id == collId: break
else:
blogCollaboratorService.addCollaboratorAsDefault(blogId, collId)
def createBlogAdmins():
blogCollaboratorService = entityFor(IBlogCollaboratorService)
assert isinstance(blogCollaboratorService, IBlogCollaboratorService)
for name, blog in BLOG_ADMINS.items():
blogId, collId = getBlogsIds()[blog], getCollaboratorsIds()[name]
blgs = blogCollaboratorService.getAll(blogId)
for blg in blgs:
if blg.Id == collId: break
else:
blogCollaboratorService.addCollaborator(blogId, collId, 'Administrator')
def populateRootRole():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roles = roleService.getAll(limit=1, q=QRole(name=NAME_ROOT))
if not roles:
rootRole = Role()
rootRole.Name = NAME_ROOT
rootRole.Description = NC_('security role', 'Default role that provides access to all available roles and rights')
roleService.insert(rootRole)
def createBlogCollaborators():
blogCollaboratorService = entityFor(IBlogCollaboratorService)
assert isinstance(blogCollaboratorService, IBlogCollaboratorService)
for name, blog in BLOG_COLLABORATORS.items():
blogId, collId = getBlogsIds()[blog], getCollaboratorsIds()[name]
blgs = blogCollaboratorService.getAll(blogId)
for blg in blgs:
if blg.Id == collId: break
else:
blogCollaboratorService.addCollaborator(blogId, collId)
def getLanguagesIds():
languageService = entityFor(ILanguageService)
assert isinstance(languageService, ILanguageService)
languages = {lang.Code: lang.Id for lang in languageService.getAll()}
for code in LANGUAGES:
if code not in languages:
lang = LanguageEntity()
lang.Code = code
languages[code] = languageService.insert(lang)
return languages
def populateRights():
'''
Synchronize the active acl rights with the database rights.
'''
rightTypeService = support.entityFor(IRightTypeService)
assert isinstance(rightTypeService, IRightTypeService)
rightService = support.entityFor(IRightService)
assert isinstance(rightService, IRightService)
for aclType in acl().activeTypes(resourcesRoot()):
assert isinstance(aclType, TypeAcl), 'Invalid acl type %s' % aclType
try: rightType = rightTypeService.getByName(aclType.name)
except InputError:
rightType = RightType()
rightType.Name = aclType.name
rightType.Description = aclType.description
rightTypeId = rightTypeService.insert(rightType)
else:
# Update the description if is the case
assert isinstance(rightType, RightType)
if rightType.Description != aclType.description:
rightType.Description = aclType.description
rightTypeService.update(rightType)
rightTypeId = rightType.Id
aclRights = {right.name: right for right in aclType.activeRights(resourcesRoot())}
for right in rightService.getAll(rightTypeId):
assert isinstance(right, Right), 'Invalid right %s' % right
aclRight = aclRights.pop(right.Name, None)
if aclRight:
assert isinstance(aclRight, RightBase)
# Update the description if is the case
if right.Description != aclRight.description:
right.Description = aclRight.description
rightService.update(right)
for aclRight in aclRights.values():
right = Right()
right.Type = rightTypeId
right.Name = aclRight.name
right.Description = aclRight.description
rightService.insert(right)
def populateDefaulyGateways():
serviceGateway = entityFor(IGatewayService)
assert isinstance(serviceGateway, IGatewayService)
for data in defaultGateways():
custom = copyContainer(data, Custom())
assert isinstance(custom, Custom)
try:
serviceGateway.insert(custom)
except InputError:
log.info('Gateway \'%s\' already exists' % custom.Name)
def populateUsersRoles():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
try: roleService.getById('Admin')
except InputError:
role = Role()
role.Name = 'Admin'
role.Description = 'Full access role'
roleService.insert(role)
def getBlogTypesIds():
blogTypeService = entityFor(IBlogTypeService)
assert isinstance(blogTypeService, IBlogTypeService)
blogTypes = {}
for name in BLOG_TYPES:
blgTypes = blogTypeService.getAll(q=QBlogType(name=name))
if blgTypes: blogTypes[name] = next(iter(blgTypes)).Id
else:
blgType = BlogType()
blgType.Name = name
blogTypes[name] = blogTypeService.insert(blgType)
return blogTypes
def blogRoleEditorId():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roles = roleService.getAll(limit=1, q=QRole(name='Editor'))
try: editor = next(iter(roles))
except StopIteration:
editor = Role()
editor.Name = NC_('security role', 'Editor')
editor.Description = NC_('security role', 'Role that allows editor stuff')
return roleService.insert(editor)
return editor.Id
def insertTheme():
s = entityFor(IBlogThemeService)
assert isinstance(s, IBlogThemeService)
for name in ("big-screen",):
q = QBlogTheme(name=name)
l = s.getAll(q=q)
if not l:
t = BlogTheme()
t.Name = name
t.URL = cdmGUI().getURI(themes_path() + "/" + name, "http")
t.IsLocal = True
s.insert(t)
def rootRoleId():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roles = roleService.getAll(limit=1, q=QRole(name='ROOT'))
try: rootRole = next(iter(roles))
except StopIteration:
rootRole = Role()
rootRole.Name = NC_('security role', 'ROOT')
rootRole.Description = NC_('security role', 'Default role that provides access to all available roles and rights')
return roleService.insert(rootRole)
return rootRole.Id
def getBlogTypesIds():
blogTypeService = entityFor(IBlogTypeService)
assert isinstance(blogTypeService, IBlogTypeService)
blogTypes = {}
for name in BLOG_TYPES:
blgTypes = blogTypeService.getAll(q=QBlogType(name=name))
if blgTypes: blogTypes[name] = next(iter(blgTypes)).Id
else:
blgType = BlogType()
blgType.Name = name
blogTypes[name] = blogTypeService.insert(blgType)
return blogTypes
def blogRoleAdministratorId():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roles = roleService.getAll(limit=1, q=QRole(name='Administrator'))
try: admin = next(iter(roles))
except StopIteration:
admin = Role()
admin.Name = NC_('security role', 'Administrator')
admin.Description = NC_('security role', 'Role that allows all rights')
return roleService.insert(admin)
return admin.Id
def cleanup():
timeout, cleanup = cleanup_timeout(), support.entityFor(IAuthenticationService)
# TODO: fix this after merge with devel
schedule = scheduler(time.time, time.sleep)
def executeCleanup():
assert isinstance(cleanup, ICleanupService)
cleanup.cleanExpired()
schedule.enter(timeout, 1, executeCleanup, ())
schedule.enter(timeout, 1, executeCleanup, ())
Thread(target=schedule.run, name='Cleanup authentications/sessions thread').start()
def blogRoleCollaboratorId():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roles = roleService.getAll(limit=1, q=QRole(name='Collaborator'))
try: collaborator = next(iter(roles))
except StopIteration:
collaborator = Role()
collaborator.Name = NC_('security role', 'Collaborator')
collaborator.Description = NC_('security role', 'Role that allows submit to desk and edit his own posts')
return roleService.insert(collaborator)
return collaborator.Id
def blogRoleCollaboratorId():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roles = roleService.getAll(limit=1, q=QRole(name='Collaborator'))
try: collaborator = next(iter(roles))
except StopIteration:
collaborator = Role()
collaborator.Name = NC_('security role', 'Collaborator')
collaborator.Description = NC_('security role', 'Role that allows submit to desk and edit his own posts')
return roleService.insert(collaborator)
return collaborator.Id
def insertTheme():
s = entityFor(IBlogThemeService)
assert isinstance(s, IBlogThemeService)
for name in ('big-screen', ):
q = QBlogTheme(name=name)
l = s.getAll(q=q)
if not l:
t = BlogTheme()
t.Name = name
t.URL = cdmGUI().getURI(themes_path() + '/' + name, 'http')
t.IsLocal = True
s.insert(t)
def blogRoleAdministratorId():
roleService = support.entityFor(IRoleService)
assert isinstance(roleService, IRoleService)
roles = roleService.getAll(limit=1, q=QRole(name='Administrator'))
try: admin = next(iter(roles))
except StopIteration:
admin = Role()
admin.Name = NC_('security role', 'Administrator')
admin.Description = NC_('security role', 'Role that allows all rights')
return roleService.insert(admin)
return admin.Id
def insertThemes():
s = entityFor(IBlogThemeService)
assert isinstance(s, IBlogThemeService)
for name in ('default', 'tageswoche','tageswoche-multi', 'tageswoche-solo','stt', 'genapp', 'big-screen', 'zeit', 'ctkepr', 'ctkeu', 'ctkih', 'ctkno', 'ctkr', 'aamulehti', 'satakansa', 'okfn', 'sasa', 'sasa-light', 'ksml', 'ksml-light', 'sz', 'rp'):
q = QBlogTheme()
q.name = name
l = s.getAll(q=q)
if not l:
t = BlogTheme()
t.Name = name
t.URL = cdmGUI().getURI(embed_themes_path() + '/' + name, 'http')
t.IsLocal = True
s.insert(t)
def insertThemes():
s = entityFor(IBlogThemeService)
assert isinstance(s, IBlogThemeService)
for name in ('default', 'tageswoche','tageswoche-multi', 'tageswoche-solo','stt', 'genapp', 'big-screen', 'zeit', 'ctkepr', 'ctkeu', 'ctkih', 'ctkno', 'ctkr', 'aamulehti', 'satakansa', 'okfn', 'sasa', 'sasa-light', 'ksml', 'ksml-light', 'sz', 'rp'):
q = QBlogTheme()
q.name = name
l = s.getAll(q=q)
if not l:
t = BlogTheme()
t.Name = name
t.URL = cdmGUI().getURI(themes_path() + '/' + name, 'http')
t.IsLocal = True
s.insert(t)
def insertThemes():
s = entityFor(IBlogThemeService)
assert isinstance(s, IBlogThemeService)
for name in ('default', 'generic'):
q = QBlogTheme()
q.name = name
l = s.getAll(q=q)
if not l:
t = BlogTheme()
t.Name = name
t.URL = cdmGUI().getURI(embed_themes_path() + '/' + name, 'http')
t.IsLocal = True
s.insert(t)
def insertThemes():
s = entityFor(IBlogThemeService)
assert isinstance(s, IBlogThemeService)
for name in ('default', 'tageswoche', 'stt'):
q = QBlogTheme()
q.name = name
l = s.getAll(q=q)
if not l:
t = BlogTheme()
t.Name = name
t.URL = cdmGUI().getURI(themes_path() + '/' + name, 'http')
t.IsLocal = True
s.insert(t)
def insertThemes():
s = entityFor(IBlogThemeService)
assert isinstance(s, IBlogThemeService)
for name in ("default", "generic"):
q = QBlogTheme()
q.name = name
l = s.getAll(q=q)
if not l:
t = BlogTheme()
t.Name = name
t.URL = cdmGUI().getURI(embed_themes_path() + "/" + name, "http")
t.IsLocal = True
s.insert(t)
def createBlogTypePosts():
blogTypePostService = entityFor(IBlogTypePostService)
assert isinstance(blogTypePostService, IBlogTypePostService)
for data in BLOG_TYPE_POSTS:
pst = BlogTypePostPersist()
blogType, pst.Type, creator, author, pst.Name, pst.Content = data
blogTypeId = getBlogTypesIds()[blogType]
exists = False
for post in blogTypePostService.getAll(blogTypeId):
if post.Content == pst.Content: exists = True; break
if not exists:
pst.Creator = getUsersIds()[creator]
if author: pst.Author = getCollaboratorsIds()[author]
blogTypePostService.insert(blogTypeId, pst)
def getSourcesIds():
sourcesService = entityFor(ISourceService)
assert isinstance(sourcesService, ISourceService)
sources = {}
for name in SOURCES:
srcs = sourcesService.getAll(q=QSource(name=name))
if srcs: sources[name] = next(iter(srcs)).Id
else:
src = Source()
src.Name = name
src.IsModifiable, src.URI, src.Type, src.Key = SOURCES[name]
createSourceType(src.Type)
sources[name] = sourcesService.insert(src)
return sources
def getUsersIds():
userService = entityFor(IUserService)
assert isinstance(userService, IUserService)
if not _cache_users:
users = _cache_users
for name in USERS:
usrs = userService.getAll(adminId=None, q=QUser(name=name))
if usrs: users[name] = next(iter(usrs)).Id
else:
usr = User()
usr.Name = name
usr.Password = hashlib.sha512(b'a').hexdigest()
usr.FirstName, usr.LastName, usr.EMail = USERS[name]
users[name] = userService.insert(adminId=None, user=usr)
return _cache_users
def getBlogsIds():
blogService = entityFor(IBlogService)
assert isinstance(blogService, IBlogService)
blogs = {}
for name, data in defaultBlogs().items():
blgs = blogService.getAll(q=QBlog(title=name))
if blgs: blogs[name] = next(iter(blgs)).Id
else:
blg = Blog()
blg.Title = name
blogType, usrName, langCode, blg.Description, blg.CreatedOn, blg.LiveOn = data
blg.Type = getBlogTypesIds()[blogType]
blg.Creator = getUsersIds()[usrName]
blg.Language = getLanguagesIds()[langCode]
blogs[name] = blogService.insert(blg)
return blogs
def cleanup():
if not perform_cleanup(): return
timeout, cleanup = cleanup_timeout(), support.entityFor(ICleanupService)
schedule = scheduler(time.time, time.sleep)
def executeCleanup():
assert isinstance(cleanup, ICleanupService)
cleanup.cleanExpired()
schedule.enter(timeout, 1, executeCleanup, ())
schedule.enter(timeout, 1, executeCleanup, ())
scheduleRunner = Thread(name='Cleanup authentications/sessions thread',
target=schedule.run)
scheduleRunner.daemon = True
scheduleRunner.start()
def rightId(aclRight):
'''
Provides the security right id for the provided acl right.
@param aclRight: RightAcl
The acl right to provide the id for.
@return: integer
The id of the security right.
'''
assert isinstance(aclRight, RightAcl), 'Invalid right %s' % aclRight
assert isinstance(aclRight.type,
TypeAcl), 'Invalid right %s, has no type' % aclRight
rightService = support.entityFor(IRightService)
assert isinstance(rightService, IRightService)
return rightService.getByName(aclRight.type.name, aclRight.name).Id
def cleanup():
if not perform_group_cleanup(): return
timeout, cleanup = cleanup_group_timeout(), support.entityFor(
IBlogCollaboratorGroupCleanupService)
schedule = scheduler(time.time, time.sleep)
def executeCleanup():
assert isinstance(cleanup, IBlogCollaboratorGroupCleanupService)
cleanup.cleanExpired()
schedule.enter(timeout, 1, executeCleanup, ())
schedule.enter(timeout, 1, executeCleanup, ())
scheduleRunner = Thread(name='Cleanup blog collaborator groups thread',
target=schedule.run)
scheduleRunner.daemon = True
scheduleRunner.start()
def populateVersionConfig():
generalSettingService = support.entityFor(IGeneralSettingService)
assert isinstance(generalSettingService, IGeneralSettingService)
generalSetting = GeneralSetting()
generalSetting.Group = 'version'
generalSetting.Key = 'major'
generalSetting.Value = '1'
generalSettingService.insert(generalSetting)
generalSetting.Key = 'minor'
generalSetting.Value = '6'
generalSettingService.insert(generalSetting)
generalSetting.Key = 'revision'
generalSetting.Value = '0'
generalSettingService.insert(generalSetting)
def getBlogsIds():
blogService = entityFor(IBlogService)
assert isinstance(blogService, IBlogService)
if not _cache_blogs:
blogs = _cache_blogs
for name in BLOGS:
blgs = blogService.getAll(q=QBlog(title=name))
if blgs: blogs[name] = next(iter(blgs)).Id
else:
blg = Blog()
blg.Title = name
blogType, usrName, langCode, blg.Description, blg.CreatedOn, blg.LiveOn = BLOGS[
name]
blg.Type = getBlogTypesIds()[blogType]
blg.Creator = getUsersIds()[usrName]
blg.Language = getLanguagesIds()[langCode]
blogs[name] = blogService.insert(blg)
return _cache_blogs
