def init():
BASE_DIR = os.getcwd() # 项目路径
STATIC_DIR = os.path.join(BASE_DIR, 'static') # 静态文件路径
TEMPLATE_DIR = os.path.join(BASE_DIR, 'template') # 模版HTML路径
app = aiohttp.web.Application(middlewares=[middleware_allow]) #
routes = gb.var['routes']
secret_key = 'This is the default secret_key'
secret_key = hashlib.md5(base64.b64encode(
secret_key.encode())).hexdigest().encode()
setup(app, EncryptedCookieStorage(secret_key))
aiohttp_jinja2.setup(app,
loader=jinja2.FileSystemLoader(TEMPLATE_DIR),
variable_start_string='{{{',
variable_end_string='}}}',
enable_async=True,
context_processors=[aiohttp_jinja2.request_processor])
app.router.add_static('/static/', path=STATIC_DIR, name='static')
app.router.add_routes(routes)
aiohttp_jinja2.get_env(app).globals.update(gb.var['templateFuncClassDic'])
print(
f"\033[1;32;45m*** creat {len(gb.var['global_route'].routes)} route ***\033[0m"
)
app.router.add_routes(gb.var['global_route'].routes)
return app
def test_get_env():
app = web.Application()
aiohttp_jinja2.setup(app, loader=jinja2.DictLoader({"tmpl.jinja2": "tmpl"}))
env = aiohttp_jinja2.get_env(app)
assert isinstance(env, jinja2.Environment)
assert env is aiohttp_jinja2.get_env(app)
def test_get_env(loop):
app = web.Application(loop=loop)
aiohttp_jinja2.setup(app, loader=jinja2.DictLoader(
{'tmpl.jinja2': "tmpl"}))
env = aiohttp_jinja2.get_env(app)
assert isinstance(env, jinja2.Environment)
assert env is aiohttp_jinja2.get_env(app)
def go():
app = web.Application(loop=self.loop)
aiohttp_jinja2.setup(app, loader=jinja2.DictLoader(
{'tmpl.jinja2': "tmlp"}))
env = aiohttp_jinja2.get_env(app)
self.assertIsInstance(env, jinja2.Environment)
self.assertIs(env, aiohttp_jinja2.get_env(app))
def go():
app = web.Application(loop=self.loop)
aiohttp_jinja2.setup(app,
loader=jinja2.DictLoader(
{'tmpl.jinja2': "tmlp"}))
env = aiohttp_jinja2.get_env(app)
self.assertIsInstance(env, jinja2.Environment)
self.assertIs(env, aiohttp_jinja2.get_env(app))
def run(config_file, bootstrap_port, path):
"""Starts the app as defined in the config file.
Starts the app in bootstrap mode if the bootstrap port is set via --bootstrap-port."""
config = load_config(config_file)
loop = asyncio.get_event_loop()
app_config_name = list(config.keys())[0]
try:
app_class = server_app_registry.get_plugin(app_config_name)
except ValueError as e:
raise click.UsageError(*e.args)
if bootstrap_port:
if app_class is AcmeCA:
raise click.UsageError(
f"Bootstrapping is not supported for the {app_class} at this moment."
)
click.echo(
f"Starting {app_class.__name__} in bootstrap mode on port {bootstrap_port}"
)
app_config = config[app_config_name]
app_config["port"] = bootstrap_port
app_config[
"challenge_validator"] = "dummy" # Do not validate challenges
app_config["subnets"] = [
"127.0.0.1/32",
"10.110.0.0/24",
] # Only allow localhost and the docker bridge network
# Bootstrap app does not run behind a reverse proxy:
app_config["use_forwarded_header"] = False
app_config["require_eab"] = False
else:
click.echo(f"Starting {app_class.__name__}")
if issubclass(app_class, AcmeRelayBase):
runner, site = loop.run_until_complete(
run_relay(config, path, app_class, app_config_name))
elif app_class is AcmeCA:
runner, site = loop.run_until_complete(run_ca(config, path))
else:
raise ValueError(app_class)
aiohttp_jinja2.setup(site.app, loader=jinja2.FileSystemLoader("./tpl/"))
aiohttp_jinja2.get_env(site.app).globals.update({"url_for": _url_for})
try:
loop.run_forever()
except KeyboardInterrupt:
loop.run_until_complete(runner.cleanup())
def _prepare_prayer_response_factory(response, character, app):
response['close'] = False
response['#prepared-prayers'] = {
'data':
get_env(app).get_template('character_prepared_prayers.html').render(
prayers=PRAYERS, character=character)
}
response['#prayer-slots'] = {
'data':
get_env(app).get_template('character_prayer_slots.html').render(
character=character)
}
def _prepare_spell_response_factory(response, character, app):
response['close'] = False
response['#prepared-spells'] = {
'data':
get_env(app).get_template('character_prepared_spells.html').render(
spells=SPELLS, character=character)
}
response['#spell-slots'] = {
'data':
get_env(app).get_template('character_spell_slots.html').render(
character=character)
}
def _prayer_response_factory(response, character, app):
response['#prayer-accordion'] = {
'data':
get_env(app).get_template('character_prayers_display.html').render(
prayers=PRAYERS, character=character),
'activateTooltip':
True
}
response['#prayer-slots'] = {
'data':
get_env(app).get_template('character_prayer_slots.html').render(
character=character)
}
def _spell_response_factory(response, character, app):
response['#spell-accordion'] = {
'data':
get_env(app).get_template('character_spells_display.html').render(
spells=SPELLS, character=character),
'activateTooltip':
True
}
response['#spell-slots'] = {
'data':
get_env(app).get_template('character_spell_slots.html').render(
character=character)
}
async def asyncSetUp(self) -> None:
await super().asyncSetUp()
# Create and place the self-signed certificate for openresty to use.
fake_ca = trustme.CA()
server_cert = fake_ca.issue_cert("127.0.0.1", "localhost")
cert_path = Path(self.config_sec["client"]["server_cert"])
first_in_chain = True
for pem in server_cert.cert_chain_pems:
pem.write_to_path(cert_path, append=not first_in_chain)
first_in_chain = False
fake_ca.cert_pem.write_to_path(cert_path, append=True)
key_path = cert_path.parent / "resty-auto-ssl-fallback.key"
server_cert.private_key_pem.write_to_path(key_path)
# The environment variable is set to the server cert so that the requests module uses it (certbot).
import os
os.environ["REQUESTS_CA_BUNDLE"] = self.config_sec["client"][
"server_cert"]
# Disable SSL verification for urllib3 (acmetiny).
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
# Disable resty-auto-ssl
with open("/usr/local/bin/resty-auto-ssl/dehydrated", "w") as f:
f.write("echo 1;")
self.nginx_proc = await asyncio.create_subprocess_shell(
'/usr/local/openresty/nginx/sbin/nginx -g "daemon off; master_process on;"',
None,
None,
)
runner, ca = await AcmeCA.runner(self.config_sec["ca"])
ca.register_challenge_validator(RequestIPDNSChallengeValidator())
await ca._db._recreate()
aiohttp_jinja2.setup(ca.app, loader=jinja2.FileSystemLoader("../tpl/"))
aiohttp_jinja2.get_env(ca.app).globals.update({"url_for": _url_for})
self.runner = runner
def get_template(app, template_name):
"""Helper to fetch a template"""
env = get_env(app)
try:
return env.get_template(template_name)
except (KeyError, jinja2.TemplateNotFound) as e:
raise HTTPInternalServerError(text="Template '{}' not found".format(template_name)) from e
def main():
loop = asyncio.get_event_loop()
prefix = '/terial'
app = web.Application(middlewares=[
normalize_path_middleware(),
prefix_middleware(prefix),
common_exception_middleware(),
])
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(str(script_dir / 'templates')),
context_processors=[aiohttp_jinja2.request_processor],
)
jinja_env = aiohttp_jinja2.get_env(app)
template_funcs.setup(jinja_env)
jinja_env.globals['config'] = config
jinja_env.globals['merge_dicts'] = merge_dicts
jinja_env.globals['is_dict'] = is_dict
routes.setup(app, prefix)
app['executor'] = ThreadPoolExecutor(max_workers=3)
web.run_app(app, port=9999, print=logger.info)
def _hp_response_factory(response, character, app):
add_classes = []
remove_classes = []
if character['damage'] > 0:
add_classes.append('danger')
remove_classes.append('success')
remove_classes.append('warning')
elif character['temp_hp'] < 0:
add_classes.append('warning')
remove_classes.append('success')
remove_classes.append('danger')
elif character['temp_hp'] > 0:
add_classes.append('success')
remove_classes.append('danger')
remove_classes.append('warning')
else:
remove_classes.append('success')
remove_classes.append('danger')
remove_classes.append('warning')
rest_in_peace = "" if character[
'hp'] > -10 else "<span class=\"badge\">R.I.P</span>"
response['#hp-form-content'] = {
'data':
get_env(app).get_template('character_hp_form.html').render(
character=character, classes=CLASSES),
'activateTooltip':
True
}
response['#hp-value'] = {'data': character['hp']}
response['#alive'] = {'data': rest_in_peace}
response['#hp-row'] = {
'addClass': add_classes,
'removeClass': remove_classes
}
def _class_response_factory(response, character, app):
class_list = "\n".join([
"""
<li class="list-group-item">
{}
<span class="label label-default">{}</span>
<button type="button" class="btn btn-info btn-xs" data-toggle="collapse" data-parent="#class-group" data-target="#{}-info-dynamic">?</button>
</li>""".format(class_.capitalize(), character[class_], class_, class_)
for class_ in CLASSES if character[class_] > 0
])
response['#class-value'] = {'data': class_list}
response['#prayer-section'] = {
'collapse': "show" if character['priest'] > 0 else "hide"
}
response['#spells-section'] = {
'collapse': "show" if character['wizard'] > 0 else "hide"
}
response['#powers-section'] = {
'collapse': "show" if character['warlock'] > 0 else "hide"
}
response['#class-form-content'] = {
'data':
get_env(app).get_template('character_class_form.html').render(
character=character, classes=CLASSES),
'activateTooltip':
True
}
_skill_response_factory(response, character, app)
_spell_response_factory(response, character, app)
_prayer_response_factory(response, character, app)
_hp_response_factory(response, character, app)
def setup_global_helpers(app):
env = get_env(app)
conf = app.config
# set global helpers for Jinja 2
def get_copy():
"""
Returns the copyright string for the application.
"""
now = datetime.now()
return "Copyright © {} {}".format(now.year, conf.site.copyright)
def res(*args):
return resources(args,
development=conf.development,
cache_seed=conf.cache_seed)
try:
ga_token = configuration.google_analytics
except KeyError:
ga_token = None
def google_analytics():
return ga_token
helpers = {
"copy": get_copy,
"google_analytics": google_analytics,
"resources": res
}
env.globals.update(helpers)
def setup_templates(webapp, conf):
templates = []
try:
template_modules = aio.app.config['web/%s']['modules']
except KeyError:
try:
template_modules = aio.app.config["aio/web"]["modules"]
except KeyError:
try:
template_modules = aio.app.config["aio"]["modules"]
except KeyError:
template_modules = ''
if not template_modules:
return
log.debug("Setting up templates for: %s" % webapp['name'])
for module in [x.strip() for x in template_modules.split("\n")]:
templates.append(
os.path.join(
resolve(module).__path__[0], "templates"))
env = aiohttp_jinja2.get_env(webapp)
loader = FileSystemLoader(templates)
env = aiohttp_jinja2.setup(webapp, loader=loader)
async def initialize(app):
"""Initialize server."""
# Get when the data was last modified (This will also check if DB is up)
update_datetime = (await db.get_last_modified_date()).strftime(
conf.datetime_format)
LOG.info("Update datetime: %s", update_datetime)
setattr(conf, 'update_datetime', update_datetime)
app['static_root_url'] = '/static'
env = aiohttp_jinja2.get_env(app)
#update_datetime_formatted = (await get_last_modified_date()).strftime(conf.update_datetime)
env.globals.update(
len=len,
max=max,
enumerate=enumerate,
range=range,
conf=conf,
now=strftime("%Y"),
#nsamples=await get_nsamples(),
#update_datetime=update_datetime_formatted,
)
env.filters['pluralize'] = pluralize_dj
# No need to call those 2:
# assemblyIDs = await db.fetch_assemblyids()
# datasets = await db.fetch_datasets()
LOG.info("Initialization done.")
def get_template(app, template_name):
"""Helper to fetch a template"""
env = get_env(app)
try:
return env.get_template(template_name)
except (KeyError, jinja2.TemplateNotFound) as e:
raise HTTPInternalServerError(
text="Template '{}' not found".format(template_name)) from e
def _coin_response_factory(response, character, app):
for coin in COINS:
response['#{}-tooltip'.format(coin)] = {'activateTooltip': True}
response['#coins'] = {
'data':
get_env(app).get_template('character_coins.html').render(
character=character, coins=COINS)
}
def test_init_jinja2():
app = web.Application()
init_themes(app)
init_jinja2(app)
assert app["static_root_url"] == "/static"
env = aiohttp_jinja2.get_env(app)
assert env.globals["themes"] == get_mdl_themes().keys()
assert env.globals["themes"] == app["themes"].keys()
def get_template(app, data):
if isinstance(data, str):
return FormatRender(app, data)
elif not isinstance(data, dict):
raise NotImplementedError()
elif 'template' in data:
env = aiohttp_jinja2.get_env(app)
return env.get_template(data['template'])
def test_filters_factory(self):
web_app = yield from self._get_web_app()
yield from factories.filters_factory(
web_app,
{'filters': (
"my_filter "
+ "aio.web.server.tests.test_factories.example_filter")})
env = aiohttp_jinja2.get_env(web_app)
self.assertEqual(
env.filters['my_filter'],
aio.web.server.tests.test_factories.example_filter)
def test_templates_factory_no_config(self):
"""
[web/TEST]
"""
web_app = yield from self._get_web_app()
yield from factories.templates_factory(
web_app,
{})
env = aiohttp_jinja2.get_env(web_app)
with self.assertRaises(AttributeError):
env.list_templates()
def test_templates_factory_web_conf(self):
"""
[web/TEST]
modules = aio.web.server.tests
"""
web_app = yield from self._get_web_app()
yield from factories.templates_factory(
web_app,
{'modules': 'aio.web.server.tests'})
env = aiohttp_jinja2.get_env(web_app)
self.assertEqual(
[x for x in env.list_templates(extensions=["html"])],
['fragments/test_fragment.html', 'test_template.html'])
def start():
"""Start Web server."""
config = DndConfiguration()
# asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
app = web.Application(debug=config.server.debug)
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(
resource_filename(Requirement.parse('dnd'), 'dnd/templates')),
auto_reload=config.server.debug,
context_processors=[aiohttp_login.flash.context_processor])
aiohttp_session.setup(
app,
EncryptedCookieStorage(config.server.session_secret,
max_age=config.server.session_max_age))
aiohttp_jinja2.get_env(app).filters['to_roman'] = toRoman
aiohttp_jinja2.get_env(app).filters['max'] = max
aiohttp_jinja2.get_env(app).filters['cutoff_dict'] = _cutoff_dict_filter
app.middlewares.append(aiohttp_login.flash.middleware)
app['db_client'] = AsyncIOMotorClient()
app['db'] = app['db_client'].dnd
auth_settings = {}
for setting in config.authentication:
auth_settings[setting.upper()] = config.authentication[setting]
aiohttp_login.setup(app, MotorStorage(app['db']), auth_settings)
app.router.add_static("/static/",
path=Path(__file__) / ".." / "static",
name="static")
app.router.add_get("/", index_handler)
app.router.add_post("/api/new-character/", new_character_data_handler)
app.router.add_get("/{id}/{name}/", character_handler)
app.router.add_post("/api/{id}/{attribute}/{extra}/", data_handler)
app.router.add_post("/api/{id}/{attribute}/", data_handler)
web.run_app(app, host=config.server.ip, port=config.server.port)
cleanup_resources()
def test_templates_factory_multiple_modules(self):
"""
[web/TEST]
modules = aio.web.server.tests
"""
web_app = yield from self._get_web_app()
yield from factories.templates_factory(
web_app,
{'modules': 'aio.web.server.tests\naio.web.server'})
env = aiohttp_jinja2.get_env(web_app)
templ_list = [
x for x in env.list_templates(extensions=["html"])]
self.assertEqual(
sorted(templ_list),
['fragments/test_fragment.html', 'test_template.html'])
def _skill_response_factory(response, character, app):
response['#skill-accordion'] = {
'data':
get_env(app).get_template('character_skills_display.html').render(
character=character),
'activateTooltip':
True
}
response['#skill-slots'] = {
'data':
character['unspent_skill_slots'],
'addClass': ["label-danger"]
if character['unspent_skill_slots'] < 0 else ["label-default"],
'removeClass': ["label-danger"]
if character['unspent_skill_slots'] >= 0 else ["label-default"]
}
def init_jinja2(app: web.Application) -> None:
"""
Initialize jinja2 template for application.
"""
aiohttp_jinja2.setup(
app,
context_processors=[
request_processor,
aiohttp_jinja2.request_processor,
],
loader=jinja2.FileSystemLoader(str(PROJECT_DIR / "templates")),
default_helpers=True,
)
app["static_root_url"] = "/static"
env = aiohttp_jinja2.get_env(app)
env.globals.update(themes=app["themes"].keys())
def test_default_template_path():
agent = Agent("jid@server", "password")
env = get_env(agent.web.app)
loader = env.loader
package_loader = loader.loaders[0]
filesystem_loader = loader.loaders[1]
assert type(loader) == ChoiceLoader
assert len(loader.loaders) == 2
assert type(package_loader) == PackageLoader
assert type(filesystem_loader) == FileSystemLoader
assert "agent.html" in package_loader.list_templates()
assert "agent.html" not in filesystem_loader.list_templates()
assert filesystem_loader.searchpath == ["."]
def test_add_template_path():
agent = Agent("jid@server", "password")
agent.web.start(templates_path="/tmp/spade")
env = get_env(agent.web.app)
loader = env.loader
assert type(loader) == ChoiceLoader
assert len(loader.loaders) == 3
assert type(loader.loaders[0]) == FileSystemLoader
assert type(loader.loaders[1]) == PackageLoader
assert type(loader.loaders[2]) == FileSystemLoader
filesystem_loader = loader.loaders[0]
assert filesystem_loader.list_templates() == []
assert filesystem_loader.searchpath == ["/tmp/spade"]
def __init__(
self, *,
from_string=None,
template_name=None,
app=None,
env=None,
):
if env is not None:
self._env = env
elif app is not None:
self._env = aiohttp_jinja2.get_env(app)
else:
self._env = None
if from_string:
self.template = self._env.from_string(from_string)
elif self._env:
self.template = self._env.get_template(template_name)
else:
raise ValueError()
def test_default_template_path():
agent = Agent("jid@server", "password")
env = get_env(agent.web.app)
loader = env.loader
package_loader = loader.loaders[0]
filesystem_loader = loader.loaders[1]
assert type(loader) == ChoiceLoader
assert len(loader.loaders) == 2
assert type(package_loader) == PackageLoader
assert type(filesystem_loader) == FileSystemLoader
assert "internal_tpl_agent.html" in package_loader.list_templates()
assert "internal_tpl_agent.html" not in filesystem_loader.list_templates()
assert filesystem_loader.searchpath == ["."]
agent.stop()
def test_add_template_path():
agent = Agent("jid@server", "password")
agent.web.start(templates_path="/tmp/spade")
env = get_env(agent.web.app)
loader = env.loader
assert type(loader) == ChoiceLoader
assert len(loader.loaders) == 3
assert type(loader.loaders[0]) == FileSystemLoader
assert type(loader.loaders[1]) == PackageLoader
assert type(loader.loaders[2]) == FileSystemLoader
filesystem_loader = loader.loaders[0]
assert filesystem_loader.list_templates() == []
assert filesystem_loader.searchpath == ["/tmp/spade"]
agent.stop()
def setup_server():
app = web.Application()
# Add static file serving:
app.router.add_static('/static', 'example/static')
# Add template file serving:
jinja_loader = jinja2.FileSystemLoader('example/templates')
aiohttp_jinja2.setup(app, loader=jinja_loader)
# Allows to use zip in jinja templates
env = aiohttp_jinja2.get_env(app)
env.globals.update(zip=zip)
app.add_routes(define_routes())
print(
'Server ready, try it: http://localhost:8080/squares?values=1,2,3,4,5,6'
)
return app
def __init__(self, app):
self.app = app
env = get_env(app)
if env is None:
text = ("Template engine is not initialized, "
"call aiohttp_jinja2.setup(...) first"
"")
# in order to see meaningful exception message both: on console
# output and rendered page we add same message to *reason* and
# *text* arguments.
raise web.HTTPInternalServerError(reason=text, text=text)
self._set_asset_paths(app)
# We only want to refresh the webpack stats in development mode,
# not everyone sets this setting, so let's assume it's production.
if app.settings.DEBUG:
app.on_response_prepare.append(self._refresh_webpack_stats)
env.globals['asset_url_for'] = self.asset_url_for
def _trace_render_template(func, module, args, kwargs):
"""
Trace the template rendering
"""
# get the module pin
pin = Pin.get_from(aiohttp_jinja2)
if not pin or not pin.enabled():
return func(*args, **kwargs)
# original signature:
# render_template(template_name, request, context, *, app_key=APP_KEY, encoding='utf-8')
template_name = args[0]
request = args[1]
env = aiohttp_jinja2.get_env(request.app)
# the prefix is available only on PackageLoader
template_prefix = getattr(env.loader, "package_path", "")
template_meta = "{}/{}".format(template_prefix, template_name)
with pin.tracer.trace("aiohttp.template", span_type=SpanTypes.TEMPLATE) as span:
span.set_meta("aiohttp.template", template_meta)
return func(*args, **kwargs)
async def set_secure_headers(request, handler):
"""Add secure headers to requests.
Parameters
----------
request : aiohttp.web.Request
The request to set secure headers on.
handler : function
The middleware handler function.
Returns
-------
aiohttp.web.Response
The modified response to the request.
"""
nonce = b64encode(uuid4().bytes).decode("utf-8")
script_src = [
"'self'",
"blob:",
# SecurePolicies.CSP().Values.nonce(nonce),
f"'nonce-{nonce}'",
"https://unpkg.com",
"'unsafe-eval'",
"'unsafe-inline'",
]
style_src = [
"'self'",
"'unsafe-inline'",
"https://fonts.googleapis.com/css2",
]
if request.path == "/api/v1/docs":
script_src[2] = "'unsafe-inline'"
style_src.append("'unsafe-inline'")
get_env(request.app).globals["csp_nonce"] = nonce
secure_headers = deepcopy(request.app["secure_headers"])
secure_headers.csp.script_src(*script_src).style_src(*style_src)
resp = await handler(request)
secure_headers.framework.aiohttp(resp)
return resp
def init(loop, argv):
logging.getLogger('asyncio').addFilter(SkipTimeouts())
#
# define your command-line arguments here
#
config = get_config(argv)
# setup application and extensions
app = create_app(config=config)
setup_routes(app)
aiohttp_jinja2.setup(app,
loader=jinja2.PackageLoader(MAIN_APP_NAME,
'templates'))
# create connection to the database
app.on_startup.append(init_pg)
# shutdown db connection on exit
app.on_cleanup.append(close_pg)
jinja_env = aiohttp_jinja2.get_env(app)
jinja_env.globals['STATIC'] = '/static/'
jinja_env.globals['_'] = app['gettext']
# Locale settings
return app
def _trace_render_template(func, module, args, kwargs):
"""
Trace the template rendering
"""
# get the module pin
pin = Pin.get_from(aiohttp_jinja2)
if not pin or not pin.enabled():
return func(*args, **kwargs)
# original signature:
# render_template(template_name, request, context, *, app_key=APP_KEY, encoding='utf-8')
template_name = args[0]
request = args[1]
env = aiohttp_jinja2.get_env(request.app)
# the prefix is available only on PackageLoader
template_prefix = getattr(env.loader, 'package_path', '')
template_meta = '{}/{}'.format(template_prefix, template_name)
with pin.tracer.trace('aiohttp.template') as span:
span.span_type = http.TEMPLATE
span.set_meta('aiohttp.template', template_meta)
return func(*args, **kwargs)
async def create_app():
config = read_configuration_file()
db_pool = await attach_db(config)
app = web.Application(middlewares=[error_middleware, babel_middleware])
app["config"] = config
app["db-pool"] = db_pool
app["mailer"] = MassMailer()
# beware of order !
setup_session(app)
setup_security(
app,
SessionIdentityPolicy(),
DBAuthorizationPolicy(db_pool)
)
app.middlewares.append(aiohttp_session_flash.middleware)
template_dir = op.join(op.dirname(op.abspath(__file__)), "templates")
aiohttp_jinja2.setup(
app,
loader=FileSystemLoader(template_dir),
context_processors=(
aiohttp_session_flash.context_processor,
authorized_userid_context_processor
)
)
jinja2_env = aiohttp_jinja2.get_env(app)
jinja2_env.globals['_'] = _
setup_routes(app)
app.on_cleanup.append(cleanup)
return app
async def send_confirmation(request, email_address, token_data, route, subject,
template_name):
config = request.app["config"]
token = generate_token(config["application"]["secret_key"], **token_data)
url = config["application"]["url"] + \
str(request.app.router[route].url_for(token=token))
env = get_env(request.app)
template = env.get_template("auth/{}.txt".format(template_name))
text_part = template.render(url=url)
text_message = MIMEText(text_part, "plain")
template = env.get_template("auth/{}.html".format(template_name))
html_part = template.render(url=url)
html_message = MIMEText(html_part, "html")
message = MIMEMultipart("alternative")
message["subject"] = "[{}] {}".format(config["application"]["site_name"],
subject)
message["to"] = email_address
message["from"] = config["application"]["from"]
message.attach(text_message)
message.attach(html_message)
await request.app["mailer"].send_urgent_message(message, email_address)
app.router.register_route(route)
template_dirs = [
os.path.realpath(os.path.join(settings.APPS_DIR, app_dir, 'templates'))
for app_dir in os.listdir(settings.APPS_DIR)
]
template_dirs.append(os.path.join(settings.WEB_DIR, 'templates'))
aiohttp_jinja2.setup(
app,
context_processors=[
aiohttp_jinja2.request_processor,
],
loader=TemplateLoader(template_dirs)
)
env = aiohttp_jinja2.get_env(app)
env.filters['tsformat'] = tsformat
env.filters['platform_group_link'] = platform_group_link
if settings.DEBUG:
aiohttp_debugtoolbar.setup(app, intercept_redirects=False)
for add_url in get_project_urls(settings.APPS_DIR):
add_url(app.router)
logging.config.dictConfig(settings.LOG_SETTINGS)
logger = logging.getLogger('aiohttp.server')
app.logger = logger
async def on_prepare(request, response):
def setup_filters(webapp, conf):
if conf.get("filters"):
env = aiohttp_jinja2.get_env(webapp)
for filt in conf['filters'].split("\n"):
name, handler = [x for x in filt.split(" ") if x]
env.filters[name] = resolve(handler)