def handle_delete(self):
data, errors = self.extractData()
del self.context.__parent__[self.context.__name__]
role_manager = IPrincipalRoleManager(grok.getSite())
for role_id, setting in role_manager.getRolesForPrincipal(data['login']):
role_manager.removeRoleFromPrincipal(role_id, data['login'])
self.redirect(self.url(grok.getSite(), '/benutzer'))
def handle_signin(self, **data):
"""signin button and signin action
"""
# create the people
people = People()
self.applyData(people, **data)
# check the login is not taken
if people.login in self.peoplelist:
msg = _(u'This username already exists: %s')
SessionMessageSource().send(
translate(msg, context=self.request) % people.login)
return self.redirect('signin')
# generate a weak but nice password
password = u''.join([
choice([
'z', 'r', 't', 'p', 'q', 's', 'd', 'f', 'g', 'h', 'j', 'k',
'l', 'm', 'w', 'x', 'c', 'v', 'b', 'n'
]) + choice(['a', 'e', 'i', 'o', 'u', 'y']) for i in range(4)
])
people.password = password
# send an email with the password
site = grok.getSite()
email = _(u'''Content-Type: text/plain; charset=UTF-8
Subject: your account for %s
Dear %s %s,
Thanks for your account!
You can connect to %s with the following informations:
%s
login : %s
password : %s''')
url = absoluteURL(site, self.request)
if ('HTTP_X_FORWARDED_SCHEME' in self.request
and 'HTTP_X_FORWARDED_SERVER' in self.request):
url = (self.request['HTTP_X_FORWARDED_SCHEME'] + '://' +
self.request['HTTP_X_FORWARDED_SERVER'])
email = translate(email, context=self.request) % (
site.name, people.firstname, people.lastname, site.name, url,
people.login, password)
mailer = getUtility(IMailDelivery, 'afpy.barcamp')
if 'nomail' not in self.request:
mailer.send('*****@*****.**', people.email.encode('utf-8'),
email.encode('utf-8'))
# add the user
self.peoplelist[people.login] = people
# grant him the Member role
prm = IPrincipalRoleManager(grok.getSite())
prm.assignRoleToPrincipal('afpy.barcamp.Member', people.login)
self.redirect('confirmation')
def addUser(self, username, password, real_name):
user_folder = grok.getSite()['users']
if username not in user_folder:
user = Account(username, password, real_name)
user_folder[username] = user
role_manager = IPrincipalRoleManager(grok.getSite())
role_manager.assignRoleToPrincipal('merlot.Manager', username)
def handle_add(self):
data, errors = self.extractData()
if errors:
self.flash(u'Es ist ein Fehler aufgetreten', 'warning')
return
changes = apply_data_event(self.fields, self.context, data)
role_manager = IPrincipalRoleManager(grok.getSite())
for role_id, setting in role_manager.getRolesForPrincipal(data['login']):
role_manager.removeRoleFromPrincipal(role_id, data['login'])
role_manager.assignRoleToPrincipal(data['role'], data['login'])
print role_manager.getRolesForPrincipal(data['login'])
self.redirect(self.url(grok.getSite(), '/benutzer'))
def handle_login(self, **data):
authenticated = not IUnauthenticatedPrincipal.providedBy(
self.request.principal, )
if authenticated:
camefrom = self.request.form.get('camefrom')
if camefrom:
self.redirect(camefrom, self.url(grok.getSite()))
else:
self.redirect(self.url(grok.getSite()))
self.flash(u'Logueado!', type=u'message')
else:
self.status = u'Autenticación fallida'
self.errors += (Invalid(u'Usuario y/o contraseña invalidos'), )
self.form_reset = False
def handle_login(self, **data):
authenticated = not IUnauthenticatedPrincipal.providedBy(
self.request.principal,
)
if authenticated:
camefrom = self.request.form.get('camefrom')
if camefrom:
self.redirect(camefrom, self.url(grok.getSite()))
else:
self.redirect(self.url(grok.getSite()))
self.flash(u'Logueado!', type=u'message')
else:
self.status = u'Autenticación fallida'
self.errors += (Invalid(u'Usuario y/o contraseña invalidos'),)
self.form_reset = False
def addUser(self, username, email, password, real_name, role):
if username not in self.user_folder:
user = Account(username, email, password, real_name, role)
self.user_folder[username] = user
role_manager = IPrincipalRoleManager(grok.getSite())
print role, username
role_manager.assignRoleToPrincipal(role, username)
def _results(self, data):
"""Make the query and transform the result in a dict with the
necessary data to display in the.
"""
catalog = getUtility(ICatalog, context=grok.getSite())
intids = getUtility(IIntIds, name='intids')
results = defaultdict(lambda: {'hours': 0,
'tasks': defaultdict(\
lambda: {'users': set(),
'hours': 0})})
query = self._query(data)
logs = list(catalog.searchResults(**query))
for log in logs:
task = intids.getObject(log.task())
project = intids.getObject(log.project())
# projects data
results[log.project()]['id'] = project.id
results[log.project()]['title'] = project.title
results[log.project()]['url'] = self.url(project)
results[log.project()]['hours'] += log.hours
# task data
results[log.project()]['tasks'][log.task()]['id'] = task.id
results[log.project()]['tasks'][log.task()]['title'] = task.title
results[log.project()]['tasks'][log.task()]['url'] = self.url(task)
results[log.project()]['tasks'][log.task()]['hours'] += log.hours
results[log.project()]['tasks'][log.task()]['users'].add(log.user)
return results
def render(self):
catalog = getUtility(ICatalog, context=grok.getSite())
request = self.request
to_date = lambda x: datetime.strptime(x, DATE_FORMAT).date()
data = {}
data['from_date'] = to_date(request['from_date'])
data['to_date'] = to_date(request['to_date'])
data['project_or_client'] = request['project_or_client']
data['user'] = request['user']
query = build_logs_report_query(data)
logs = list(catalog.searchResults(**query))
logs.sort(key=lambda x: x.date)
log_dicts = []
for log in logs:
d = {'user': log.user,
'project': log.__parent__.__parent__.title,
'task': log.__parent__.title,
'description': log.description,
'date': log.date,
'hours': log.hours}
log_dicts.append(d)
keys = ('user', 'project', 'task', 'description', 'date', 'hours')
csv = CSVGenerator(log_dicts, keys).generate()
self.response.setHeader('Content-Disposition',
'attachment; filename=report.csv;')
csv.seek(0)
return csv.read()
def save(self, **data):
'''
Create an InternalPrincipal with the user data.
This method also grants the ViewMemberListing permission to the user.
'''
login = data['login']
pau = getUtility(IAuthentication)
principals = pau['principals']
# XXX: the login name must be unique; need better handling of this
if login in principals:
msg = _(u'Login name taken. Please choose a different one.')
self.widgets['login']._error = ValidationError(msg)
self.form_reset = False
else:
# create an instance of InternalPrincipal
principal = InternalPrincipal(passwordManagerName='SHA1', **data)
principals[login] = principal
# grant the user permission to view the member listing
permission_mngr = IPrincipalPermissionManager(grok.getSite())
permission_mngr.grantPermissionToPrincipal(
'plainlogindemo.ViewMemberListing', principals.prefix + login)
self.redirect(
self.url('login') + '?' + urlencode({'login': login}))
def applyPermissionsForExistentCoUsers(factory):
site = grok.getSite()
hfm = IHomeFolderManager(site)
principal = factory.object
master_id = IMasterUser(principal).id
if hfm.get(master_id) is None:
hfm.create(IMasterUser(principal).id)
homefolder = principal.homefolder #IHomeFolder(principal)
if homefolder is None:
return
um = getUtility(IUserManagement)
user = um.getUser(principal.id)
if not user:
return
rollen = user['rollen']
if user['az'] != '00':
pid = "%s-%s" % (user['mnr'], user['az'])
else:
pid = user['mnr']
if homefolder.__name__ != pid:
for pf in homefolder.keys():
if pf in rollen:
prm = IPrincipalRoleManager(homefolder.get(pf))
if prm.getSetting('uvc.Editor', pid).getName() == 'Unset':
prm.assignRoleToPrincipal('uvc.Editor', pid)
uvcsite.log('Give uvc.Editor to %s in folder %s' %
(pid, pf))
def accountFromRoles(self, login):
''' Populate self.roles by querying the role manager
'''
roleMgr = IPrincipalRoleManager(grok.getSite())
for rid, setting in roleMgr.getRolesForPrincipal('gfn.'+login):
if setting.getName() == 'Allow':
self.roles.add(rid)
def getPrincipal(self, id):
print 'getprincipal called: %s' % id
source = IOAuthPrincipalSource(grok.getSite())
principal = source.find(id=id)
if len(principal) == 1:
return principal[0]
raise PrincipalLookupError(id)
def save(self, **data):
"""
Create a Member and grant it the ViewMemberListing permission.
"""
login = data['login']
members = self.context['members']
member = Member(**data)
try:
# if we can already fetch a member object based on the requested
# login id, then we create a validation exception and assign it
# to the login field
members[login]
msg = _(u'Login name taken. Please choose a different one.')
self.widgets['login']._error = ValidationError(msg)
self.form_reset = False
except KeyError:
# login id is not taken so we save the member object
# and grant the ViewMemberListing permission to the login id
members[login] = member
permission_mngr = IPrincipalPermissionManager(grok.getSite())
permission_mngr.grantPermissionToPrincipal(
'babylogindemo.ViewMemberListing', 'babylogindemo' + login)
self.redirect(
self.url('login') + '?' + urlencode({'login':login})
)
def save(self, **data):
'''
Create an InternalPrincipal with the user data.
This method also grants the ViewMemberListing permission to the user.
'''
login = data['login']
pau = getUtility(IAuthentication)
principals = pau['principals']
# create an instance of InternalPrincipal
principal = InternalPrincipal(**data)
try:
principals[login] = principal
except DuplicateIDError:
# create a validation exception and assign it to the login field
msg = _(u'Login name taken. Please choose a different one.')
self.widgets['login']._error = ValidationError(msg)
self.form_reset = False # preserve the values in the fields
else:
# grant the user permission to view the member listing
permission_mngr = IPrincipalPermissionManager(grok.getSite())
permission_mngr.grantPermissionToPrincipal(
'plainlogindemo.ViewMemberListing', principals.prefix + login)
self.redirect(
self.url('login') + '?' + urlencode({'login': login}))
def values(self):
rc = []
root = grok.getSite()
for x in self.context.antworten:
locate(root, x, DefaultModel)
rc.append(x)
return sorted(rc, key=lambda antwort: antwort.frage.frage)
def update(self):
main_css.need()
main_js.need()
site = grok.getSite()
self.base = absoluteURL(site, self.request)
if IContainer.providedBy(self.context) and self.base[:-1] != '/':
self.base = self.base + '/'
def handle_add(self):
data, errors = self.extractData()
if errors:
self.flash(u'Es ist ein Fehler aufgetreten', 'warning')
return
users = component.getUtility(IAuthenticatorPlugin, 'principals')
users.addUser(data['login'], data['email'], data['password'], data['real_name'], data['role'])
self.redirect(self.url(grok.getSite(), '/benutzer'))
def update(self):
super(SignIn, self).update()
self.peoplelist = queryUtility(IPeopleContainer,
context=grok.getSite())
if self.peoplelist is None:
# there is no people container at the toplevel
SessionMessageSource().send(_(u'Please choose the meeting first'))
self.redirect('index')
def logout(self):
site = grok.getSite()
sm = site.getSiteManager()
auth = sm.getUtility(IAuthentication)
if not queryAdapter(auth, ILogoutSupported):
self.redirect(self, url(self.context, '@@balogout'))
ILogout(auth).logout(self.request)
self.redirect(self.request.URL)
def members(self):
members = grok.getSite()['members']
member_count = len(members)
if member_count == 0:
return _(u'No one has')
elif member_count == 1:
return _(u'One member has')
else:
return unicode(member_count) + _(u' members have')
def __call__(self, context=None):
site = grok.getSite()
users = site['users'].values()
users = [SimpleTerm(u.id, u.id, u.real_name) for u in users]
all_users = (u'all', u'all', _(u'All users'))
users.insert(0, SimpleTerm(*all_users))
return SimpleVocabulary(users)
def deleteFromStarredLists(self):
"""Remove the task from the starred tasks lists"""
app = grok.getSite()
intids = getUtility(IIntIds, name='intids')
for user in app['users'].values():
starred_tasks = ifaces.IStarredTasks(user)
intid = intids.getId(self)
starred_tasks.removeStarredTask(intid)
def GET(self):
self.response.setHeader('Content-Type',
'application/xml; charset=UTF-8')
app_url = grok.url(self.request, grok.getSite())
tree = export(self.context, Settings(expand='compact',
app_url=app_url))
self.response.setStatus(200)
embed_http(self.request, self.response, tree)
return etree.tostring(tree, encoding='UTF-8')
def handle_login(self, **data):
if component.getUtility(IAuthentication).authenticate(self.request) is None:
message.send(_('Wrong Login or Password'))
else:
message.send(_('Login successful'))
if data.get('camefrom', None):
self.redirect(data.get('camefrom', ''))
else:
self.redirect(self.url(grok.getSite()))
def security_notifier(self):
"""Get a local security notifier.
The security notifier is installed as a local utility by an
event handler triggered on startup.
"""
site = grok.getSite()
site_manager = site.getSiteManager()
return site_manager.queryUtility(ISecurityNotifier, default=None)
def __call__(self, context):
terms = []
sm = component.getSiteManager(grok.getSite())
adapters = sm.adapters.lookupAll((ITokenRequest,), IOAuthPrincipal)
for name, _a in adapters:
value = name
token = str(name)
title = name
terms.append(SimpleVocabulary.createTerm(value,token,title))
return SimpleVocabulary(terms)
def rolesFromAccount(self):
''' Populate the managed roles for this principal from self.roles
'''
roleMgr = IPrincipalRoleManager(grok.getSite())
if self.login == 'admin':
self.roles.add('gfn.Administrator')
for rid, _setting in roleMgr.getRolesForPrincipal('gfn.'+self.login):
roleMgr.unsetRoleForPrincipal(rid, 'gfn.'+self.login)
for role in self.roles:
roleMgr.assignRoleToPrincipal(role, 'gfn.'+self.login)
def update(self):
form = self.request.form
# we automatically register for the meeting (which is the nearest Site)
IRegistration(grok.getSite()).register(self.request.principal.id)
if not form.get('form.author', '').strip():
form['form.author'] = \
ISession(self.request)['afpy.barcamp'].get('nick')
super(Add, self).update()
def handleSearch(self):
data, errors = self.extractData()
if errors:
return
session = Session()
sql = session.query(Teilnehmer).filter(Teilnehmer.id == data.get('teilnehmer_id'))
if sql.count() == 0:
self.flash('Es wurde kein Teilnehmer mit der ID %s gefunden' %data.get('teilnehmer_id'))
teilnehmer = sql.one()
locate(grok.getSite(), teilnehmer, DefaultModel)
self.redirect(self.url(teilnehmer, 'register'))
def authenticateCredentials(self, credentials):
if not isinstance(credentials, dict):
return None
if not ('login' in credentials and 'password' in credentials):
return None
# hardcoded admin account TODO Arghhh
if credentials['login'] != 'admin' or credentials[
'password'] != 'barcamp':
return None
# grant permission to the hardcoded admin
IPrincipalPermissionManager(grok.getSite()).grantPermissionToPrincipal(
'zope.ManageContent', 'admin')
IPrincipalPermissionManager(grok.getSite()).grantPermissionToPrincipal(
'afpy.barcamp.managemeetings', 'admin')
IPrincipalPermissionManager(grok.getSite()).grantPermissionToPrincipal(
'afpy.barcamp.editseance', 'admin')
IPrincipalPermissionManager(grok.getSite()).grantPermissionToPrincipal(
'afpy.barcamp.seances.list', 'admin')
return PrincipalInfo(id='admin',
title=_(u'admin'),
description=_(u'admin'))
def update(self):
# check if we need an upgrade
self.need_upgrade = False
if 'rooms' not in self.context.keys():
self.need_upgrade = True
# do the upgrade if asked
if 'do_upgrade' in self.request:
# UPGRADE
self.context['rooms'] = rooms = Rooms()
sm = grok.getSite().getSiteManager()
sm.registerUtility(rooms, IRooms)
SessionMessageSource().send(_(u'Database successfully upgraded!'))
def handle_login(self, **data):
authenticated = not IUnauthenticatedPrincipal.providedBy(
self.request.principal,
)
if authenticated:
self.redirect(self.request.form.get('camefrom',
self.url(grok.getSite())))
self.flash(_(u'You are logged in.'), type=u'message')
else:
self.status = _(u'Login failed.')
self.errors += (Invalid(u'Invalid username and/or password'),)
self.form_reset = False
def agregarUsuario(self, usuario, password, confirm_password, nombre_real,
rol, seccion):
if usuario not in self.contenedor_cuentas:
user = Cuenta(usuario, password, nombre_real, rol, seccion)
self.contenedor_cuentas[usuario] = user
role_manager = IPrincipalRoleManager(grok.getSite())
if rol == u'empleado':
role_manager.assignRoleToPrincipal('ct.empleadorol', usuario)
if rol == u'administrador':
role_manager.assignRoleToPrincipal('ct.adminrol', usuario)
else:
return u"El nombre de usuario ya existe"
def get_root_folder():
"""Get the Root Folder of a Zope instance."""
site = grok.getSite()
if IApplication.providedBy(site):
return site.__parent__
else:
# another sub-site is within the application, so
# walk up the tree until we get to the root folder
parent = site.__parent__
while not IRootFolder.providedBy(parent):
parent = parent.__parent__
return parent
def submit(self, **data):
catalog = getUtility(ICatalog, context=grok.getSite())
query = build_logs_report_query(data)
self.logs = list(catalog.searchResults(**query))
self.logs.sort(key=lambda x: x.date)
self.total_hours = sum([l.hours for l in self.logs])
self.csv_url = ('@@logs-report-csv?project_or_client=%s&'
'from_date=%s&to_date=%s&user=%s') % \
(data['project_or_client'],
data['from_date'],
data['to_date'],
data['user'])
def __call__(self, context=None):
site = grok.getSite()
path = getUtility(IObjectPath).path
projects = [i for i in site['projects'].values() if \
ifaces.IProject.providedBy(i)]
title = lambda p: '%s (%s)' % (p.title, p.client.to_object.title)
projects = [SimpleTerm(path(p), path(p), title(p)) for p in projects]
all_projects = (u'all', u'all', _(u'All projects'))
projects.insert(0, SimpleTerm(*all_projects))
return SimpleVocabulary(projects)
def render(self, uninstall=False):
site = grok.getSite()
sm = site.getSiteManager()
name = 'OpenAuth2'
print "%s" % [k for k in sm.keys()]
if uninstall and name in sm.keys():
util = sm[name]
sm.unregisterUtility(component=util, provided=IAuthentication)
del sm[name]
elif name not in sm.keys():
obj = sm[name] = OAuth2Authenticate()
sm.registerUtility(component=obj, provided=IAuthentication)
print 'installed'
self.redirect(self.url(self.context))
def agregarUsuario(self, usuario, password,
confirm_password, nombre_real, rol, seccion):
if usuario not in self.contenedor_cuentas:
user = Cuenta(usuario, password, nombre_real, rol, seccion)
self.contenedor_cuentas[usuario] = user
role_manager = IPrincipalRoleManager(grok.getSite())
if rol == u'empleado':
role_manager.assignRoleToPrincipal('ct.empleadorol',
usuario)
if rol == u'administrador':
role_manager.assignRoleToPrincipal('ct.adminrol',
usuario)
else:
return u"El nombre de usuario ya existe"
def render(self):
el = etree.Element('{%s}%s' % (NS, 'search-result'), nsmap={None:NS})
tree = etree.ElementTree(el)
app_url = self.url(grok.getSite())
settings = Settings('expand=all', app_url=app_url)
for obj in self.search_result:
r = IXml(obj)
r.serialize(el, settings, url=self.url(obj))
self.response.setHeader('Content-Type',
'text/xml; charset=UTF-8')
return etree.tostring(tree, encoding='UTF-8')
def __init__(self, *args, **kwargs):
''' Create an administrator with default login and password
'''
super(AuthenticatorPlugin, self).__init__(*args, **kwargs)
su = InternalPrincipal(login='******', password='******', title=u'Administrator',
description=u'The SuperUser')
self['admin'] = su
roleMgr = IPrincipalRoleManager(grok.getSite())
for uid, _setting in roleMgr.getPrincipalsForRole('gfn.Administrator'):
roleMgr.unsetRoleForPrincipal('gfn.Administrator', 'gfn.'+uid)
uid = self.getIdByLogin('admin')
roleMgr.assignRoleToPrincipal('gfn.Administrator', 'gfn.'+uid)
def getResults(self):
root = grok.getSite()
lf_vocab = lieferstopps(None)
for teilnehmer, kursteilnehmer in self.results:
locate(root, kursteilnehmer, DefaultModel)
#locate(root, teilnehmer.unternehmen, DefaultModel)
name = '<a href="%s"> %s %s </a>' %(self.url(kursteilnehmer), teilnehmer.name, teilnehmer.vorname)
rcu = []
for unt in teilnehmer.unternehmen:
locate(root, unt, DefaultModel)
rcu.append('<a href="%s"> %s %s </a>' %(self.url(unt), unt.mnr, unt.name))
r = dict(name=name,
id = teilnehmer.id,
status=lf_vocab.getTerm(kursteilnehmer.status).title,
unternehmen=','.join(rcu))
yield r
def getApplication():
"""Return the nearest enclosing `grok.Application`.
Raises ValueError if no Application can be found.
"""
site = grok.getSite()
if grok.interfaces.IApplication.providedBy(site):
return site
# Another sub-site is within the application. Walk up the object
# tree until we get to the an application.
obj = site
while obj is not None:
if isinstance(obj, grok.Application):
return obj
obj = obj.__parent__
raise ValueError("No application found.")
def handle_login(self, **data):
''' If the authentication plugins are not yet installed, install them
'''
pau = queryUtility(IAuthentication)
if pau is None or type(pau) is not PluggableAuthenticatorPlugin:
installer = ISiteLocalInstaller(grok.getSite())
installer.registerUtility(PluggableAuthenticatorPlugin,
provided=IAuthentication,
name_in_container='pau')
installer.registerUtility(AuthenticatorPlugin,
provided=IAuthenticatorPlugin,
name='users')
pau = queryUtility(IAuthentication)
if pau is not None: pau.authenticate(self.request)
self.redirect(self.url(self.context, data=data))
def authenticateCredentials(self, credentials):
if not isinstance(credentials, dict):
return None
if not 'login' in credentials or not 'password' in credentials:
return None
login = credentials.get('login')
password = credentials.get('password')
if login is None or password is None:
return None
peoplelist = getUtility(IPeopleContainer, context=grok.getSite())
people = peoplelist.get(login)
if people is None:
return None
if not people.check_password(password):
return None
return PrincipalInfo(id=people.login,
title=people.login,
description=people.login)
def namespace(self):
tn = None
unternehmenl = []
ktns = []
root = grok.getSite()
zs = self.getSession()
if zs.get('tn'):
tn = zs.get('tn')
session = Session()
tn = session.query(Teilnehmer).get(int(tn))
locate(root, tn, DefaultModel)
for unternehmen in tn.unternehmen:
locate(root, unternehmen, DefaultModel)
unternehmenl.append(unternehmen)
for ktn in tn.kursteilnehmer:
locate(root, ktn, DefaultModel)
ktns.append(ktn)
return {'teilnehmer': tn, 'unternehmen': unternehmenl, 'kursteilnehmer': ktns}
def findReturnTo(view):
returnTo = view.request.getHeader('Referer')
# No referrer or referrer is the language selector view.
if (returnTo is None or
not returnTo.startswith(view.application_url()) or
returnTo == view.request.getURL()):
names = []
context = view.context
site = grok.getSite()
while context != site:
if interfaces.ILocalizedContentContainer not in \
zope.interface.providedBy(context.__parent__):
names.append(context.__name__)
context = context.__parent__
names.reverse()
returnTo = "%s/%s" % (view.application_url(), "/".join(names))
return returnTo
def updateSecurityNotifier(self, setsecnotes=None, setsecnotesource=None,
secnotesource=None):
if self.security_notifier is None:
site = grok.getSite()
site_manager = site.getSiteManager()
if 'grokadmin_security' not in site_manager:
site_manager['grokadmin_security'] = SecurityNotifier()
utility = site_manager['grokadmin_security']
site_manager.registerUtility(
utility, ISecurityNotifier, name=u'')
if setsecnotesource is not None:
self.security_notifier.setLookupURL(secnotesource)
if setsecnotes is not None:
if self.security_notifier.enabled is True:
self.security_notifier.disable()
else:
self.security_notifier.enable()
if self.secnotes_enabled is False:
return
return
def authenticate(self, request):
members = grok.getSite()['members']
login = request.get('login', None)
password = request.get('password', None)
cookie = request.get('babylogindemo.auth', None)
# if login and password are submitted with the request,
# save them in a cookie, otherwise get the cookie and
# extract the login and password from them
if login and password:
val = base64.encodestring('%s:%s' % (login, password))
request.response.setCookie('babylogindemo.auth',
urllib.quote(val),
path='/')
elif cookie:
val = base64.decodestring(urllib.unquote(cookie))
login, password = val.split(':')
# XXX check the password, eh!
try:
return members[login]
except KeyError:
return None
def add(self, **data):
nick = self.request.principal.id
peoplelist = getUtility(IPeopleContainer, context=grok.getSite())
if nick not in peoplelist:
msg = _(u'Please first register')
SessionMessageSource().send(msg)
self.redirect(self.url(''))
obj = Seance()
self.applyData(obj, **data)
# add the author
obj.authors.add(self.request.principal.id)
# TODO generate a correct slug that removes accents
name = data['name'].lower().replace(' ', '_').replace('/', '_')
self.context[name] = obj
# assign a local role, just for this seance
IPrincipalRoleManager(obj).assignRoleToPrincipal(
'afpy.barcamp.SeanceLeader', self.request.principal.id)
self.redirect(self.url(obj) + '/@@added')
def update(self):
self.sorted_seances = list(
getUtility(ISeanceContainer,
context=grok.getSite()).values())
self.sorted_seances.sort(start_date_sort)
super(Index, self).update()
def __init__(self, context, request):
super(SystemError, self).__init__(context, request)
self.context = grok.getSite()
self.origin_context = context
RESPONSE = self.request.response
RESPONSE.setHeader('content-type', 'text/html')
def render(self):
datefmt = self.request.locale.dates.getFormatter('date').format
site = grok.getSite()
durations = [dur.title for dur in site['durations'].values()]
# Excel styling
base_sty_str = 'border: top thin, left thin, right thin, bottom thin; align: wrap yes, vert centre, horz centre;'
colors = itertools.cycle((
'coral',
'light_green',
'tan',
'ivory',
'pale_blue',
'light_yellow',
'lavender',
'grey25',
'rose',
'light_turquoise',
'periwinkle',
'ice_blue',
)) # Just in case we have more than 12 different durations
header_sty = xlwt.easyxf(base_sty_str + 'font: bold on')
durations = dict(
(d,
xlwt.easyxf(base_sty_str +
'pattern: pattern solid, fore-colour %s;' %
colors.next())) for d in durations)
wb = xlwt.Workbook()
seances = [
v for v in self.context.values()
if v.status == 'confirmed' and v.start_date is not None
]
rooms = sorted(set(s.room.title for s in seances))
by_date = dict()
errors = []
for s in seances:
by_date.setdefault(s.start_date.timetuple()[:3], []).append(s)
for date_tuple, day_seances in sorted(by_date.iteritems()):
sheet_name = datefmt(date(*date_tuple))
by_room = dict()
for s in day_seances:
by_room.setdefault(s.room.title, []).append(s)
ws = wb.add_sheet(sheet_name)
start_hour = min(s.start_date.hour for s in day_seances)
end_hour = max(s.end_date.hour for s in day_seances) + 1
hours = [
'%d:%.2d' % (k, v) for k in xrange(start_hour, end_hour)
for v in xrange(0, 60, 15)
]
for line, h in enumerate(hours):
ws.write(line + 1, 0, h, header_sty)
for col, room in enumerate(rooms):
ws.col(col + 1).width = 0x2500
ws.write(0, col + 1, room, header_sty)
for seance in by_room.get(room, []):
start_line = 1 + (seance.start_date.hour - start_hour
) * 4 + seance.start_date.minute / 15
minutes_step, mod = divmod(seance.duration.value, 15)
if mod == 0:
minutes_step -= 1
end_line = start_line + minutes_step
try:
ws.write_merge(start_line, end_line, col + 1, col + 1,
seance.name,
durations[seance.duration.title])
except:
errors.append(seance)
# write legend
start = len(hours) + 3
for i, (value, style) in enumerate(sorted(durations.iteritems())):
ws.write(start + i, 1, value, style)
ws.show_grid = False
ws.panes_frozen = True
ws.horz_split_pos = 1
ws.vert_split_pos = 1
ws.portrait = True
for error in errors:
logging.error(
'Seance %s starting on %s and ending on %s in room %s is overriding another seance',
error.name, error.start_date, error.end_date, error.room.title)
# output
fd, fname = tempfile.mkstemp()
wb.save(fname)
content = file(fname).read()
os.close(fd)
os.unlink(fname)
self.request.response.setHeader('Content-type',
'application/vnd.ms-excel')
self.request.response.setHeader('Content-disposition',
'attachment; filename=planning.xls')
return content
def homeFolderBase(self):
return grok.getSite()['members']
def canEdit(self):
if self.request.principal.id == 'zope.manager':
return True
# return True
from zope.security import checkPermission
return checkPermission('OAuth2.editing', grok.getSite())
def get_account(name):
util = getUtility(IAuthenticatorPlugin, "users")
account = util.getAccount(name)
if account is not None:
located(account, grok.getSite(), name)
return account
def getAppTitle(self):
"""Get the title of our blog.
"""
return grok.getSite().title
def borrarUsuario(self, usuario):
if usuario in self.contenedor_cuentas:
role_manager = IPrincipalRoleManager(grok.getSite())
rol = role_manager.getRolesForPrincipal(usuario)[0]
role_manager.removeRoleFromPrincipal(rol[0], usuario)
del self.contenedor_cuentas[usuario]
def getPeople(self, id):
return getUtility(IPeopleContainer, context=grok.getSite()).get(id)
def getProductFolder(self):
base = grok.getSite()['dokumente']
folder_name = time.strftime('%Y_%m_%d', time.localtime())
if not folder_name in base.keys():
base[folder_name] = AdHocProductFolder()
return base[folder_name]
