def __init__(self, context, request): self.context = context self.request = request self.session = request.session if 'logged' not in self.session: HTTPFound(location='/logout') data = osPbbUser.get_by_user_id(self.session['user_id']) if data: self.session['kd_kanwil'] = data.kd_kanwil self.session['kd_kantor'] = data.kd_kantor #session['kd_kppbb'] =data.kd_kppbb #session['kd_bank_tunggal']=data.kd_bank_tunggal #session['kd_bank_persepsi']=data.kd_bank_persepsi else: if self.session['userid'] == 'sa': self.session['kd_kanwil'] = '09' self.session['kd_kantor'] = '19' else: HTTPFound(location='/logout') renderer = get_renderer("../../templates/layout.pt") self.layout = renderer.implementation().macros['layout'] renderer = get_renderer("../../templates/main.pt") self.main = renderer.implementation().macros['main'] renderer = get_renderer("../../templates/pbb/nav.pt") self.nav = renderer.implementation().macros['nav']
def add_base_template(event): main = get_renderer('templates/main.pt').implementation() generic_macros = get_renderer('templates/macro/generic_macros.pt').implementation() base_search = get_renderer('templates/base/search.pt').implementation() event.update({'main': main}) event.update({'generic_macros': generic_macros}) event.update({'base_search': base_search})
def add_renderer(self, delivery_format, renderer_name): """ Adds a matching to the render proxy's matching dict. It is possible to overwrite an existing one. If you do, a notice (warning) is printed to your server logs. :param delivery_format: The format string to which the renderer should be bound to (e.g. "json", "xml", ...) :type delivery_format: str :param renderer_name: The name of the renderer which was used to assign it to the pyramid applications configuration. :type renderer_name: str :raises: ConfigurationError """ try: get_renderer(renderer_name) self._format_to_renderer[delivery_format] = renderer_name log.warning('You overwrite the renderer for the "{format_name}" format'.format(format_name=delivery_format)) except ValueError, e: text = 'Adding mapping from format "{format_name}" to renderer "{renderer_name}" could not be completed. ' \ 'The renderer "{renderer_name}" does not exist. Original error was: {error_txt}'.format( format_name=delivery_format, renderer_name=renderer_name, error_txt=e ) log.warning(text) raise ConfigurationError()
def add_base_template(event): """Add base templates. """ main = get_renderer('templates/indexLTE.pt').implementation() test = get_renderer('templates/main.pt').implementation() email_main = get_renderer('templates/email/main.pt').implementation() event.update({'main': main, 'test': test, 'email_main': email_main})
def swordfish(context,request): logged_in = authenticated_userid(request) main = get_renderer('../templates/register.pt').implementation() if not 'god' in context: context["god"] = User("god", hashlib.sha1("eden".encode('UTF-8')).digest(), 777777, firstName = "Jesus", lastName = "Christ", email = "*****@*****.**", phone = "777-777-7707", gradYear = 2013, inductionYear = 0, isofficer=True, isadvisor=True); context["god"].__parent__ = context return {'red':'','main':get_renderer('../templates/register.pt').implementation(),'content':'And on the eighth day, Man created God','logged_in':authenticated_userid(request),'name':'Apotheosis Sucessful (:'} return {'red':'','main':get_renderer('../templates/register.pt').implementation(),'content':'You already have a God','logged_in':authenticated_userid(request),'name':'Apotheosis Failed D:'}
def get_document(context, request): path = request.path.split('/') if path[-1] == 'edit': docid = path[-2] doc = IDatabase(context).get_document(docid) return render_to_response( "templates/editdocument.pt", { 'title': doc.title, 'body': doc.display(edit=True), 'save_url': doc.url + '/save', 'formid': doc.form.id, 'master': get_renderer('templates/master.pt').implementation(), }, request) elif path[-1] == 'save': docid = path[-2] doc = IDatabase(context).get_document(docid) doc.save(request.params) return HTTPFound( location=doc.url ) else: docid = path[-1] doc = IDatabase(context).get_document(docid) return render_to_response( "templates/opendocument.pt", { 'title': doc.title, 'body': doc.display(), 'master': get_renderer('templates/master.pt').implementation(), }, request)
def site_layout(level): if level == 'min': renderer = get_renderer("arsenalweb:templates/min_layout.pt") else: renderer = get_renderer("arsenalweb:templates/global_layout.pt") layout = renderer.implementation().macros['layout'] return layout
def patient_list_view(request): # get other templates that will be included via macros footer = get_renderer('../templates/va-footer.pt').implementation() logo = get_renderer('../templates/va-logo.pt').implementation() nav = get_renderer('../templates/va-navigation.pt').implementation() patientidentification = get_renderer('../templates/patient-identification.pt').implementation() return {'project': 'mmpspupc', 'footer': footer, 'logo': logo, 'nav': nav, 'patientidentification': patientidentification}
def edit_group(context, request): if 'id' in request.matchdict: try: group = DBSession().query(Group).get(request.matchdict.get('id')) is_new = False except SQLAlchemyError: raise HTTPNotFound if not group: raise HTTPNotFound else: group = Group() is_new = True schema = GroupSchema(after_bind=maybe_remove_fields).bind(request=request, group=group) form = deform.Form(schema, buttons=('zapisz', 'anuluj'), css_class=u'form-horizontal', requirements = ( ('bootstrap', None), )) js.deform.auto_need(form) if request.POST: if not 'zapisz' in request.POST: return HTTPFound(location='/groups/only_mine') items = request.POST.items() try: appstruct = form.validate(items) except deform.ValidationFailure, e: return {'form': e.render(), 'group_nav': get_renderer('templates/group_macros.pt').implementation(), 'group': group, 'main': get_renderer('templates/master.pt').implementation()} if 'activation_code' in request.POST: group.state = u'aktywna' request.session.flash({'title': u'Gotowe!', 'body': u'Grupa %s została aktywowana.' % group.name}, queue='success') return HTTPFound(location='/groups/%s' % group.id) if appstruct['logo']: logo = File() logo.filename = appstruct['logo']['filename'] logo.mimetype = appstruct['logo']['mimetype'] appstruct['logo']['fp'].seek(0) logo.data = appstruct['logo']['fp'].read() appstruct['logo']['fp'].seek(0,2) logo.size = appstruct['logo']['fp'].tell() appstruct['logo']['fp'].close() appstruct['logo'] = logo group = merge_session_with_post(group, appstruct) session = DBSession() session.add(group) if is_new: group.add_member(request.user, 'owner') request.session.flash({'title': u'Gotowe!', 'body': u'Grupa %s została stworzona.' % group.name}, queue='success') else: request.session.flash({'title': u'Gotowe!', 'body': u'Grupa %s została zaktualizowana.' % group.name}, queue='success') return HTTPFound(location='/groups/only_mine')
def add_base_template(event): """Add base templates. """ main = get_renderer('work-program.pt').implementation() doc_template = get_renderer('doc-page.pt').implementation() event.update({'work_program_template': main, 'doc_template': doc_template, })
def try_template(template_name): try: logger.debug("trying template %s", template_name) get_renderer(template_name).template_loader().render({}) return True except TemplateNotFound as ex: return False except: return True
def add_base_template(event): """ Expose the base template as per the Pyramid cookbook: https://docs.pylonsproject.org/projects/pyramid_cookbook/dev/templates.html#using-a-beforerender-event-to-expose-chameleon-base-template """ base = get_renderer('templates/base.pt').implementation() event.update({'base': base}) base = get_renderer('templates/base_bare.pt').implementation() event.update({'basebare': base})
def bridal_party(request): if (request.host.startswith('localhost') or request.host.startswith('suralka')): bridal_party_renderer = 'templates/surag_bridal_party.pt' main = get_renderer('templates/surag_index.pt').implementation() else: bridal_party_renderer = 'templates/bridal_party2.pt' main = get_renderer('templates/index.pt').implementation() args = {'main': main} return render_to_response(bridal_party_renderer, args, request=request)
def our_story(request): if (request.host.startswith('localhost') or request.host.startswith('suralka')): story_renderer = 'templates/surag_our_story.pt' main = get_renderer('templates/surag_index.pt').implementation() else: story_renderer = 'templates/our_story.pt' main = get_renderer('templates/index.pt').implementation() args = {'main': main} return render_to_response(story_renderer, args, request=request)
def __init__(self, request): self.request = request self.context = request.context self.site = find_root(request.context) ## FIXME: could be reified (?) self.admin_layout = get_renderer( 'petrel:templates/admin_layout.pt').implementation() self.admin_toolbar = get_renderer( 'petrel:templates/toolbar.pt').implementation().macros['toolbar'] self.context_url = request.resource_url(request.context) self.user_md = get_user_metadata(self.request)
def my_view(request): # get other templates that will be included via macros footer = get_renderer('../templates/va-footer.pt').implementation() logo = get_renderer('../templates/va-logo.pt').implementation() nav = get_renderer('../templates/va-navigation.pt').implementation() try: # one = DBSession.query(MyModel).filter(MyModel.name == 'one').first() one = None except DBAPIError: return Response(conn_err_msg, content_type='text/plain', status_int=500) return {'one': one, 'project': 'mmpspupc', 'footer': footer, 'logo': logo, 'nav': nav}
def add_templates(event): base = get_renderer('templates/base.pt').implementation() frontend = get_renderer('templates/frontend.pt').implementation() backend = get_renderer('templates/backend.pt').implementation() macros = get_renderer('templates/macros.pt').implementation() event.update({ 'base': base, 'frontend': frontend, 'backend': backend, 'm': macros })
def __init__(self, context, request): self.context = context self.request = request renderer = get_renderer("../../../templates/layout.pt") self.layout = renderer.implementation().macros['layout'] renderer = get_renderer("../../../templates/main.pt") self.main = renderer.implementation().macros['main'] renderer = get_renderer("../../../templates/pbb/nav.pt") self.nav = renderer.implementation().macros['nav']
def __init__(self, context, request): self.context = context self.request = request renderer = get_renderer("../../../templates/layout.pt") self.layout = renderer.implementation().macros['layout'] renderer = get_renderer("../../../templates/main.pt") self.main = renderer.implementation().macros['main'] renderer = get_renderer("../../../templates/pbbd/nav.pt") self.nav = renderer.implementation().macros['nav']
def __init__(self, context, request): self.context = context self.request = request self.response = dict( api = self, form_resources = {}, main_tpl_macro = get_renderer('templates/main.pt').implementation().macros['master'], view_content_tpl_macro = get_renderer('templates/view.pt').implementation().macros['view'], resource_url = resource_url, ) progress_main_css.need()
def rsvp(request): right_sidebar = get_renderer('templates/right_sidebar.pt').implementation() if (request.host.startswith('localhost') or request.host.startswith('suralka')): rsvp_renderer = 'templates/surag_rsvp.pt' main = get_renderer('templates/surag_index.pt').implementation() else: rsvp_renderer = 'templates/rsvp.pt' main = get_renderer('templates/index.pt').implementation() args = {'main': main, 'right_sidebar': right_sidebar} return render_to_response(rsvp_renderer, args, request=request)
def render(self): result = {} result['main_template'] = get_renderer( 'penelope.core:skins/main_template.pt').implementation() result['main'] = get_renderer( 'penelope.core.forms:templates/master.pt').implementation() schema = WizardSchema().clone() wizard_fanstatic.need() form = WizardForm(schema, action=self.request.current_route_url(), formid='wizard', method='POST', buttons=[ SubmitButton(title=u'Submit'), ResetButton(title=u'Reset'), ]) form['new_users'].widget = SequenceWidget() form['users'].widget = SequenceWidget(min_len=1) users = DBSession.query(User).order_by(User.fullname) form['users']['user']['usernames'].widget.values = [('', '')] + \ [(str(u.id), u.fullname) for u in users] roles = DBSession.query(Role).order_by(Role.name) form['users']['user']['role'].widget.values = [('', '')] + \ [(str(role.id), role.name) for role in roles] form['new_users']['new_user']['role'].widget.values = [('', '')] + \ [(str(role.id), role.name) for role in roles] form['milestones'].widget = SequenceWidget(min_len=1) form['contracts'].title = '' form['contracts']['customer_requests'].widget = SequenceWidget(min_len=3) controls = self.request.POST.items() if controls != []: try: appstruct = form.validate(controls) self.handle_save(form, appstruct) except ValidationFailure as e: result['form'] = e.render() return result appstruct = {} appstruct['contracts'] ={'customer_requests': []} appstruct['contracts']['customer_requests'].append({'ticket': True, 'title': u'Project management'}) appstruct['contracts']['customer_requests'].append({'ticket': True, 'title': u'Analisi'}) appstruct['contracts']['customer_requests'].append({'ticket': True, 'title': u'Supporto'}) result['form'] = form.render(appstruct=appstruct) return result
def assessment_wound_view(request): # get other templates that will be included via macros footer = get_renderer('../templates/va-footer.pt').implementation() logo = get_renderer('../templates/va-logo.pt').implementation() nav = get_renderer('../templates/va-navigation.pt').implementation() try: algorithm_id = DBSession.query(Algorithm.id).filter(func.lower(Algorithm.algorithm_name)=='assessment measure').scalar() experiment_id = DBSession.query(Experiment.id).filter(and_(Experiment.algorithm_id==algorithm_id, Experiment.default_flag==True)).scalar() patients = DBSession.query(PatientIdentification).all() except DBAPIError: return Response(conn_err_msg, content_type='text/plain', status_int=500) return {'patients': patients, 'algorithm_id':algorithm_id, 'experiment_id':experiment_id, 'project': 'mmpspupc', 'footer': footer, 'logo': logo, 'nav': nav}
def get_base_params(view=None, event=None, request=None, breadcrumbs=True, globaltabs=True, main=True, apex=True, login=True, services_portlet=True, banner=True): if event is not None: req = event['request'] view = event['view'] elif request is not None: req = request else: req = getattr(view, 'request', get_current_request()) p = {} qs = dict(req.GET) qs.update(req.POST) if apex: p['apex_form'] = get_renderer('apex:templates/forms/tableform.pt').implementation() p['apex_template'] = get_renderer('apex:templates/apex_template.pt').implementation() if banner: p['banner'] = get_renderer('../templates/includes/banner.pt').implementation() if globaltabs: p['globaltabs'] = get_renderer('../templates/includes/globaltabs.pt').implementation() if breadcrumbs:p['breadcrumbs'] = get_renderer('../templates/includes/breadcrumbs.pt').implementation() if main: p['main'] = get_renderer('../templates/master.pt').implementation() ########################### PORTLETS STUFF if login: if not 'came_from' in req.GET: if request is not None: userid = unauthenticated_userid(req) if not userid: req.GET['came_from'] = req.url login_params = apex_views.login(req) if not isinstance(login_params, HTTPFound): login_params['include_came_from'] = True login_params['self_register'] = authm.self_registration() p['login_params'] = login_params else: p['login_params'] = {} p['login_form'] = get_renderer('apex:templates/apex_template.pt').implementation() p['login'] = get_renderer('../templates/includes/login.pt').implementation() if services_portlet: p['services'] = get_renderer('../templates/includes/services.pt').implementation() p['classifications_service_treeview_url'] = req.resource_url(req.root) + '@@classifications_services_treeview' p['packages_service_treeview_url'] = req.resource_url(req.root) + '@@packages_services_treeview' p['u'] = req.resource_url p['root'] = getattr(req, 'root', None) p['get_globaltabs'] = get_globaltabs p['services_portlet'] = services_portlet p['get_breadcrumbs'] = get_breadcrumbs p['static'] = req.static_url('mobyle2.core:static/')[:-1] p['dstatic'] = req.static_url('deform:static/')[:-1] p['c'] = getattr(req, 'context', None) p['request'] = req return p
def macro(self, template, macro_name): '''Loads macros from any template. If settings['reload_templates'] is false, also memoizes the macros. ''' if asbool(self.request.registry.settings.get('reload_templates')): return get_renderer(template).implementation().macros[macro_name] else: macro_path = template + '|' + macro_name macro = self.macro_cache.get(macro_path) if not macro: self.macro_cache[macro_path] = macro = \ get_renderer(template).implementation().macros[macro_name] return macro
def delete_subcategory(request): subcategory_id = int(request.matchdict["subcategory_id"]) the_subcategory = ( config["DBSession"].query(AchievementSubCategory).filter(AchievementSubCategory.id == subcategory_id).first() ) the_user = config["get_user"](request) type_count = ( config["DBSession"] .query(func.count(AchievementType.id)) .filter(AchievementType.subcategory == subcategory_id) .first()[0] ) if type_count > 0: layout = get_renderer(config["layout"]).implementation() return dict( title="Delete sub category: %s" % the_subcategory.name, the_subcategory=None, message="This subcategory still has achievements in it. You cannot delete it until they are gone.", layout=layout, ) editors = achievement_functions.editors_for_subcategory(the_subcategory) if the_user.id not in editors: layout = get_renderer(config["layout"]).implementation() return dict( title="Delete sub category: %s" % the_subcategory.name, the_subcategory=None, message="You are not authorised to delete sub categories in this section", layout=layout, ) if "form.submitted" in request.params: with transaction.manager: config["DBSession"].delete(the_subcategory) the_subcategory = AchievementSubCategory() the_subcategory.name = "" the_subcategory.id = -1 layout = get_renderer(config["layout"]).implementation() return dict( title="Delete sub category: %s" % the_subcategory.name if the_subcategory != None else "Sub category deleted", layout=layout, the_subcategory=the_subcategory, )
def add_base_template(event): """ Expose the several macro templates as per the Pyramid cookbook: https://docs.pylonsproject.org/projects/pyramid_cookbook/dev/templates.html#using-a-beforerender-event-to-expose-chameleon-base-template """ base = get_renderer('views/templates/base.pt').implementation() event.update({'base': base}) dialogs = get_renderer('views/templates/dialogs.pt').implementation() event.update({'dialogs': dialogs}) macros = get_renderer('views/templates/macros.pt').implementation() event.update({'macros': macros})
def delete_subcategory(request): subcategory_id = int(request.matchdict['subcategory_id']) the_subcategory = config['DBSession'].query(AchievementSubCategory).filter( AchievementSubCategory.id == subcategory_id).first() the_user = config['get_user'](request) type_count = config['DBSession'].query(func.count( AchievementType.id)).filter( AchievementType.subcategory == subcategory_id).first()[0] if type_count > 0: layout = get_renderer(config['layout']).implementation() return dict( title='Delete sub category: %s' % the_subcategory.name, the_subcategory=None, message= "This subcategory still has achievements in it. You cannot delete it until they are gone.", layout=layout, ) editors = achievement_functions.editors_for_subcategory(the_subcategory) if the_user.id not in editors: layout = get_renderer(config['layout']).implementation() return dict( title='Delete sub category: %s' % the_subcategory.name, the_subcategory=None, message= "You are not authorised to delete sub categories in this section", layout=layout, ) if 'form.submitted' in request.params: with transaction.manager: config['DBSession'].delete(the_subcategory) the_subcategory = AchievementSubCategory() the_subcategory.name = "" the_subcategory.id = -1 layout = get_renderer(config['layout']).implementation() return dict( title='Delete sub category: %s' % the_subcategory.name if the_subcategory != None else "Sub category deleted", layout=layout, the_subcategory=the_subcategory, )
def __init__(self, context, request): self.context = context self.request = request self.session = request.session if 'logged' not in self.session: HTTPFound(location='/logout') renderer = get_renderer("../../templates/layout.pt") self.layout = renderer.implementation().macros['layout'] renderer = get_renderer("../../templates/main.pt") self.main = renderer.implementation().macros['main'] renderer = get_renderer("../../templates/apbd/nav.pt") self.nav = renderer.implementation().macros['nav']
def delete_section(request): section_id = int(request.matchdict['section_id']) the_section = config['DBSession'].query(AchievementSection).filter( AchievementSection.id == section_id).first() the_user = config['get_user'](request) category_count = config['DBSession'].query( func.count(AchievementCategory.id)).filter( AchievementCategory.section == section_id).first()[0] if category_count > 0: layout = get_renderer(config['layout']).implementation() return dict( title='Delete section: %s' % the_section.name, the_section=None, message= "This section still has sub categories. You cannot delete it until they are gone.", layout=layout, ) if the_section.owner != the_user.id: layout = get_renderer( '../templates/layouts/viewer.pt').implementation() return dict( title='Edit section: %s' % the_section.name, the_section=None, message="Only the owner can delete a section", layout=layout, ) if 'form.submitted' in request.params: with transaction.manager: config['DBSession'].delete(the_section) the_section = AchievementSection() the_section.name = "" the_section.id = -1 layout = get_renderer(config['layout']).implementation() return dict( title='Delete document: %s' % the_section.name if the_section != None else "Doc deleted", layout=layout, the_section=the_section, )
def base(self): """ Base macro renderer. Useful when creating new templates. Have a look at templates/base.pt for more details. """ renderer = get_renderer("templates/base.pt") return renderer.implementation().macros['main']
def new_game(request): config['check_blocked'](request) the_user = config['get_user_func'](request) layout = get_renderer(config['layout']).implementation() message = "" flash_colour = "A00" if "opponent_name" in request.params: opponent_name = request.params['opponent_name'].strip().upper() opponent = db.find_user(opponent_name) # Failure :( if opponent == None: message = """I'm sorry, we cannot find any opponent by the name of '{}'""".format( opponent_name) else: game_id = db.new_game(the_user.id, opponent.id) return HTTPFound(location=request.route_url("odummo.view_game", game_id=game_id)) return dict( title="Odummo", layout=layout, the_user=the_user, message=message, flash_colour=flash_colour, profile=db.get_profile(the_user.id), )
def settings_view(request): """docstring for settings_view""" master = get_renderer('templates/master.pt').implementation() tracs = None users = None formdata = Formdata() if request.params: tracs = request.params.getall("tracs")[0] users = request.params.getall("users")[0] formdata.tracs = formdata.form_parser(tracs) formdata.users = formdata.form_parser(users) with open("sql/tracs", "w") as file: pickle.dump(formdata.tracs, file) with open("sql/users", "w") as file: pickle.dump(formdata.users, file) with open("sql/tracs") as file: tracs = pickle.load(file) with open("sql/users") as file: users = pickle.load(file) tracs = formdata.create_text(tracs) users = formdata.create_text(users) formdata.tracs = tracs or None formdata.users = users or None form = Form(request) return dict(master=master, renderer=FormRenderer(form), formdata=formdata)
def serialize(self, format='html'): # prepara metadados metadados = {} metadados['total_registros'] = getattr(self,'total_registros',0) next_url = self.dataset_split.get('next_url', '') if next_url: metadados['proximos'] = next_url # formatos alternativos metadados['alternativos'] = {} url_formatos = re.compile(r"(\.)html(\??)") if url_formatos.search(self.dataset_split['current_url']): formatos = ['xml', 'json', 'csv'] metadados['alternativos'] = dict(zip(formatos, [ re.sub(url_formatos, r"\1%s\2" % formato, self.dataset_split['current_url']) for formato in formatos ] )) # traz o template do layout geral layout = get_renderer('templates/layout.pt').implementation() return render(self.template, { 'URI_BASE': URI_BASE, 'layout': layout, 'tidy_label': self.tidy_label, 'tidy_value': self.tidy_value, 'name': self.name, 'metadados': metadados, 'dataset_split': self.dataset_split, 'filters_used': self.filters_used, 'filters': self.parameters, 'd':self.aggregator, }, )
def dashboard(request): resources.unicorn.need() tinymce.need() docs = DBSession.query(Document) main = get_renderer('templates/master.pt').implementation() return {'main': main, 'docs': docs}
def _send_invitation_email(request, community, community_href, invitation): mailer = getUtility(IMailDelivery) info = _get_common_email_info(community, community_href) subject_fmt = 'Please join the %s community at %s' info['subject'] = subject_fmt % (info['c_title'], info['system_name']) body_template = get_renderer( 'templates/email_invite_new.pt').implementation() msg = Message() msg['From'] = info['mfrom'] msg['To'] = invitation.email msg['Subject'] = info['subject'] body = body_template( system_name=info['system_name'], community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], personal_message=invitation.message, invitation_url=resource_url(invitation.__parent__, request, invitation.__name__) ) if isinstance(body, unicode): body = body.encode("UTF-8") msg.set_payload(body, "UTF-8") msg.set_type('text/html') mailer.send([invitation.email,], msg)
def add_renderer_globals(event): """ add globals to templates csrf_token - bare token csrf_token_field - hidden input field with token inserted flash - flash messages """ request = event.get('request') settings = get_current_registry().settings template = settings['apex.apex_render_template'] if request is None: request = get_current_request() csrf_token = request.session.get_csrf_token() globs = { 'csrf_token': csrf_token, 'csrf_token_field': '<input type="hidden" name="csrf_token" value="%s" />' % csrf_token, 'flash': flash, } if template.endswith('.pt'): globs['flash_t'] = get_renderer('apex:templates/flash_template.pt').implementation() event.update(globs)
def _send_aeu_emails(community, community_href, profiles, text): # To make reading the add_existing_user_view easier, move the mail # delivery part here. info = _get_common_email_info(community, community_href) subject_fmt = 'You have been added to the %s community' subject = subject_fmt % info['c_title'] body_template = get_renderer( 'templates/email_add_existing.pt').implementation() html_body = text mailer = getUtility(IMailDelivery) for profile in profiles: to_email = profile.email msg = MIMEMultipart('alternative') msg['From'] = info['mfrom'] msg['To'] = to_email msg['Subject'] = subject bodyhtml = body_template( system_name=info['system_name'], community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], personal_message=html_body, ) bodyplain = html2text.html2text(bodyhtml) htmlpart = MIMEText(bodyhtml.encode('UTF-8'), 'html', 'UTF-8') plainpart = MIMEText(bodyplain.encode('UTF-8'), 'plain', 'UTF-8') msg.attach(plainpart) msg.attach(htmlpart) mailer.send([to_email], msg)
def _send_ai_email(community, community_href, username, profile): """Send email to user who has accepted a community invitation. """ info = _get_common_email_info(community, community_href) subject_fmt = 'Thank you for joining the %s community' subject = subject_fmt % info['c_title'] body_template = get_renderer( 'templates/email_accept_invitation.pt').implementation() mailer = getUtility(IMailDelivery) msg = MIMEMultipart('alternative') msg['From'] = info['mfrom'] msg['To'] = profile.email msg['Subject'] = subject bodyhtml = body_template( community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], username=username, ) bodyplain = html2text.html2text(bodyhtml) htmlpart = MIMEText(bodyhtml.encode('UTF-8'), 'html', 'UTF-8') plainpart = MIMEText(bodyplain.encode('UTF-8'), 'plain', 'UTF-8') msg.attach(plainpart) msg.attach(htmlpart) mailer.send([profile.email], msg)
def send_invitation_email(request, community, community_href, invitation): mailer = getUtility(IMailDelivery) info = _get_common_email_info(community, community_href) subject_fmt = 'Please join the %s community at %s' info['subject'] = subject_fmt % (info['c_title'], info['system_name']) body_template = get_renderer( 'templates/email_invite_new.pt').implementation() msg = MIMEMultipart('alternative') msg['From'] = info['mfrom'] msg['To'] = invitation.email msg['Subject'] = info['subject'] bodyhtml = body_template(system_name=info['system_name'], community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], personal_message=invitation.message, invitation_url=resource_url( invitation.__parent__, request, invitation.__name__)) bodyplain = html2text.html2text(bodyhtml) htmlpart = MIMEText(bodyhtml.encode('UTF-8'), 'html', 'UTF-8') plainpart = MIMEText(bodyplain.encode('UTF-8'), 'plain', 'UTF-8') msg.attach(plainpart) msg.attach(htmlpart) mailer.send([invitation.email], msg)
def _send_moderators_changed_email(community, community_href, new_moderators, old_moderators, cur_moderators, prev_moderators): info = _get_common_email_info(community, community_href) subject_fmt = 'Change in moderators for %s' subject = subject_fmt % info['c_title'] body_template = get_renderer( 'templates/email_moderators_changed.pt').implementation() profiles = find_profiles(community) all_moderators = cur_moderators | prev_moderators to_profiles = [profiles[name] for name in all_moderators] to_addrs = ["%s <%s>" % (p.title, p.email) for p in to_profiles] mailer = getUtility(IMailDelivery) msg = MIMEMultipart('alternative') msg['From'] = info['mfrom'] msg['To'] = ",".join(to_addrs) msg['Subject'] = subject bodyhtml = body_template( system_name=info['system_name'], community_href=info['c_href'], community_name=info['c_title'], new_moderators=[profiles[name].title for name in new_moderators], old_moderators=[profiles[name].title for name in old_moderators], cur_moderators=[profiles[name].title for name in cur_moderators], prev_moderators=[profiles[name].title for name in prev_moderators]) bodyplain = html2text.html2text(bodyhtml) htmlpart = MIMEText(bodyhtml.encode('UTF-8'), 'html', 'UTF-8') plainpart = MIMEText(bodyplain.encode('UTF-8'), 'plain', 'UTF-8') msg.attach(plainpart) msg.attach(htmlpart) mailer.send(to_addrs, msg)
def login(context, request): login_url = resource_url(request.root, request, 'login') referrer = request.url if referrer == login_url: referrer = '/' # never use the login form itself as came_from came_from = request.params.get('came_from', referrer) message = '' username = '' password = '' if 'form.submitted' in request.params: username = request.params['username'] password = request.params['password'] if USERS.get(username) == password: headers = remember(request, username) return HTTPFound(location=came_from, headers=headers) message = 'Incorrect user name or password.' #Get master template master_template = get_renderer('templates/master.pt').implementation() return dict( master_template=master_template, message=message, url=request.application_url + '/login', came_from=came_from, login=username, password=password, )
def huelsenbeck(request): try: methods = [request.matchdict['method']] distance_formulas = [request.matchdict['distance_formula']] k = [request.matchdict['k']] except KeyError: methods = request.GET.getall('method') distance_formulas = request.GET.getall('distance_formula') k = request.GET.getall('k') try: n = [request.matchdict['n']] m = [request.matchdict['m']] indelible_models = [request.matchdict['indelible_model']] genes = [request.matchdict['genes']] theta = [request.matchdict['theta']] except KeyError: n = request.GET.getall('n') m = request.GET.getall('m') indelible_models = request.GET.getall('indelible_model') theta = request.GET.getall('theta') genes = request.GET.getall('genes') print(distance_formulas) print(k) if len(k) > 0: k = [",".join(sorted(k))] else: k = [] filter_group = [ col.in_(vals) for col, vals in [( HuelsenbeckTreeEstimateSet.method, methods ), (HuelsenbeckTreeEstimateSet.distance_formula, distance_formulas), (HuelsenbeckTreeEstimateSet.k, k), (HuelsenbeckSimulationSet.genes, genes), (HuelsenbeckSimulationSet.indelible_model, indelible_models), ( HuelsenbeckSimulationSet.n, n), (HuelsenbeckSimulationSet.theta, theta), (HuelsenbeckSimulationSet.m, m)] if len(vals) > 0 ] tree_estimate_set_macro = get_renderer( "templates/huelsenbeck_tree_estimate_set.pt").implementation().macros huelsenbeck_tree_estimate_sets = DBSession.query(HuelsenbeckTreeEstimateSet).\ join(HuelsenbeckTreeEstimateSet.simulation_set, aliased=True).\ options(subqueryload(HuelsenbeckTreeEstimateSet.simulation_set)).\ filter(and_(*filter_group)).all() #huelsenbeck_tree_estimate_sets.sort(key=lambda huelsenbeck_tree_estimate_set: sum(huelsenbeck_tree_estimate.tree_estimate.success for huelsenbeck_tree_estimate in huelsenbeck_tree_estimate_set.huelsenbeck_tree_estimates),reverse=True) return ({ 'methods': methods, 'distance_formulas': distance_formulas, 'k': ",".join(k), 'm': m, 'genes': genes, 'huelsenbeck_tree_estimate_sets': huelsenbeck_tree_estimate_sets, 'results': [], 'tree_estimate_set_macro': tree_estimate_set_macro, 'np': np })
def __init__(self, context, request): self.context = context self.request = request # Logged User self.logged_in = authenticated_userid(request) # Main message for pages if needed self.message = u'' from easyblog.utilities import Provider from pyramid.renderers import get_renderer base = get_renderer('templates/base.pt').implementation() # This dict will be returned in every view def is_active(interface): if provides(self.context, interface): return 'active' return '' try: lang = self.request.cookies['lang'], except KeyError: from pyramid.i18n import get_locale_name lang = get_locale_name(self.request) self.base_dict = { 'logged_in': self.logged_in, 'message': self.message, 'resource_url': resource_url, 'provider': Provider(self.context, self.request), 'is_active': is_active, 'base': base, 'lang': lang }
def _send_aeu_emails(community, community_href, profiles, text): # To make reading the add_existing_user_view easier, move the mail # delivery part here. info = _get_common_email_info(community, community_href) subject_fmt = 'You have been added to the %s community' subject = subject_fmt % info['c_title'] body_template = get_renderer( 'templates/email_add_existing.pt').implementation() html_body = text mailer = getUtility(IMailDelivery) for profile in profiles: to_email = profile.email msg = Message() msg['From'] = info['mfrom'] msg['To'] = to_email msg['Subject'] = subject body = body_template( system_name=info['system_name'], community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], personal_message=html_body, ) if isinstance(body, unicode): body = body.encode("UTF-8") msg.set_payload(body, "UTF-8") msg.set_type('text/html') mailer.send([to_email,], msg)
def _send_moderators_changed_email(community, community_href, new_moderators, old_moderators, cur_moderators, prev_moderators): info = _get_common_email_info(community, community_href) subject_fmt = 'Change in moderators for %s' subject = subject_fmt % info['c_title'] body_template = get_renderer( 'templates/email_moderators_changed.pt').implementation() profiles = find_profiles(community) all_moderators = cur_moderators | prev_moderators to_profiles = [profiles[name] for name in all_moderators] to_addrs = ["%s <%s>" % (p.title, p.email) for p in to_profiles] mailer = getUtility(IMailDelivery) msg = Message() msg['From'] = info['mfrom'] msg['To'] = ",".join(to_addrs) msg['Subject'] = subject body = body_template( system_name=info['system_name'], community_href=info['c_href'], community_name=info['c_title'], new_moderators=[profiles[name].title for name in new_moderators], old_moderators=[profiles[name].title for name in old_moderators], cur_moderators=[profiles[name].title for name in cur_moderators], prev_moderators=[profiles[name].title for name in prev_moderators]) if isinstance(body, unicode): body = body.encode("UTF-8") msg.set_payload(body, "UTF-8") msg.set_type('text/html') mailer.send(to_addrs, msg)
def _send_ai_email(community, community_href, username, profile): """Send email to user who has accepted a community invitation. """ info = _get_common_email_info(community, community_href) subject_fmt = 'Thank you for joining the %s community' subject = subject_fmt % info['c_title'] body_template = get_renderer( 'templates/email_accept_invitation.pt').implementation() mailer = getUtility(IMailDelivery) msg = Message() msg['From'] = info['mfrom'] msg['To'] = profile.email msg['Subject'] = subject body = body_template( community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], username=username, ) if isinstance(body, unicode): body = body.encode("UTF-8") msg.set_payload(body, "UTF-8") msg.set_type('text/html') mailer.send([profile.email,], msg)
def _send_aeu_emails(community, community_href, profiles, text): # To make reading the add_existing_user_view easier, move the mail # delivery part here. info = _get_common_email_info(community, community_href) subject_fmt = 'You have been added to the %s community' subject = subject_fmt % info['c_title'] body_template = get_renderer( 'templates/email_add_existing.pt').implementation() html_body = text mailer = getUtility(IMailDelivery) for profile in profiles: to_email = profile.email msg = Message() msg['From'] = info['mfrom'] msg['To'] = to_email msg['Subject'] = subject body = body_template( system_name=info['system_name'], community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], personal_message=html_body, ) if isinstance(body, unicode): body = body.encode("UTF-8") msg.set_payload(body, "UTF-8") msg.set_type('text/html') mailer.send([ to_email, ], msg)
def intranet_layout(self): layout = get_renderer( 'karl.content.views:templates/intranet_layout.pt').implementation() intranet = find_interface(self.context, IIntranet) if intranet: layout.navigation = intranet.navigation return layout
def _send_ai_email(community, community_href, username, profile): """Send email to user who has accepted a community invitation. """ info = _get_common_email_info(community, community_href) subject_fmt = 'Thank you for joining the %s community' subject = subject_fmt % info['c_title'] body_template = get_renderer( 'templates/email_accept_invitation.pt').implementation() mailer = getUtility(IMailDelivery) msg = Message() msg['From'] = info['mfrom'] msg['To'] = profile.email msg['Subject'] = subject body = body_template( community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], username=username, ) if isinstance(body, unicode): body = body.encode("UTF-8") msg.set_payload(body, "UTF-8") msg.set_type('text/html') mailer.send([ profile.email, ], msg)
def debug_view(context, request): pending = request.registry.queryAdapter(context, IRegistrations, name='pending') if pending is None: pending = FauxPendingRegistrations(context) confirmed = request.registry.queryAdapter(context, IRegistrations, name='confirmed') if confirmed is None: confirmed = FauxConfirmedRegistrations(context) identity = request.environ.get('repoze.who.identity') authenticated_user = login_name = email = None if identity is not None: authenticated_user = identity['repoze.who.userid'] account_info = confirmed.get(authenticated_user) if account_info is None: authenticated_user = login_name = email = None else: login_name = account_info.login email = account_info.email main_template = get_renderer('templates/main.pt') return {'main_template': main_template.implementation(), 'authenticated_user': authenticated_user, 'login_name': login_name, 'email': email, 'pending': sorted(pending), 'confirmed': sorted(confirmed), }
def _send_invitation_email(request, community, community_href, invitation): mailer = getUtility(IMailDelivery) info = _get_common_email_info(community, community_href) subject_fmt = 'Please join the %s community at %s' info['subject'] = subject_fmt % (info['c_title'], info['system_name']) body_template = get_renderer( 'templates/email_invite_new.pt').implementation() msg = Message() msg['From'] = info['mfrom'] msg['To'] = invitation.email msg['Subject'] = info['subject'] body = body_template(system_name=info['system_name'], community_href=info['c_href'], community_name=info['c_title'], community_description=info['c_description'], personal_message=invitation.message, invitation_url=resource_url(invitation.__parent__, request, invitation.__name__)) if isinstance(body, unicode): body = body.encode("UTF-8") msg.set_payload(body, "UTF-8") msg.set_type('text/html') mailer.send([ invitation.email, ], msg)
def render(self, **kwargs): """render the form as html or json""" request = self.request if request.format != 'html': meth = getattr(self, 'render_%s_format' % request.format, None) if meth is not None: return meth(**kwargs) else: raise NotFound() if request.model_class: request.model_class = model_class = I18NModel(request.model_class, request) request.model_label = model_label = model_class.label request.model_plural = model_plural = model_class.plural else: model_class = request.model_class model_label = model_plural = '' self.update_resources() kwargs.update( main = get_renderer('pyramid_formalchemy:templates/admin/master.pt').implementation(), model_class=model_class, model_name=request.model_name, model_label=model_label, model_plural=model_plural, breadcrumb=self.breadcrumb(**kwargs), actions=request.actions, F_=get_translator()), return kwargs
def app(env, base_url=None): asset_env = env['registry'].queryUtility(IWebAssetsEnvironment) request = env['request'] context = request.context base_template = get_renderer('h:templates/base.pt').implementation() api_url = request.registry.settings.get('api.url', None) api_url = api_url or urljoin(request.host_url, '/api') app_layout = layouts.SidebarLayout(context, request) app_page = render( 'h:templates/app.pt', { 'base_url': base_url, 'layout': { 'css_links': app_layout.css_links, 'js_links': app_layout.js_links, 'csp': '', 'inline_webfont': False, }, 'main_template': base_template, 'request': request, 'service_url': api_url, }) app_html_file = join(asset_env.directory, 'app.html') with open(app_html_file, 'w', 'utf-8-sig') as f: f.write(app_page)
def render(self, **kwargs): """render the form as html or json""" request = self.request if request.format != 'html': meth = getattr(self, 'render_%s_format' % request.format, None) if meth is not None: return meth(**kwargs) else: raise NotFound() if request.model_class: request.model_class = model_class = I18NModel( request.model_class, request) request.model_label = model_label = model_class.label request.model_plural = model_plural = model_class.plural else: model_class = request.model_class model_label = model_plural = '' self.update_resources() kwargs.update(main=get_renderer( 'pyramid_formalchemy:templates/admin/master.pt').implementation(), model_class=model_class, model_name=request.model_name, model_label=model_label, model_plural=model_plural, breadcrumb=self.breadcrumb(**kwargs), actions=request.actions, F_=get_translator()), return kwargs
def preferences(request): config['check_blocked'](request) the_user = config['get_user_func'](request) profile = db.get_profile(the_user.id) layout = get_renderer(config['layout']).implementation() message = "" if "preferred_colour" in request.params: preferred_colour = request.params['preferred_colour'] if preferred_colour == "true": profile.preferred_colour = True else: profile.preferred_colour = False matchmaking = request.params['matchmaking'] if matchmaking == "true": profile.matchmaking = True else: profile.matchmaking = False message = "Changes saved" return dict( title="Odummo preferences", layout=layout, the_user=the_user, profile=profile, message=message, )