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 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 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,
)
