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 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]