def get_config_path():
"""Get the path of the indico config file.
This may return the location of a symlink. Resolving a link is up
to the caller if needed.
"""
# In certain environments (debian+uwsgi+no-systemd) Indico may run
# with an incorrect $HOME (such as /root), resulting in the config
# files being searched in the wrong place. By clearing $HOME, Python
# will get the home dir from passwd which has the correct path.
old_home = os.environ.pop('HOME', None)
# env var has priority
try:
return os.path.expanduser(os.environ['INDICO_CONFIG'])
except KeyError:
pass
# try finding the config in various common paths
paths = [os.path.expanduser('~/.indico.conf'), '/etc/indico.conf']
# Keeping HOME unset wouldn't be too bad but let's not have weird side-effects
if old_home is not None:
os.environ['HOME'] = old_home
# If it's an editable setup (ie usually a dev instance) allow having
# the config in the package's root path
if package_is_editable('indico'):
paths.insert(0, os.path.normpath(os.path.join(get_root_path('indico'), 'indico.conf')))
for path in paths:
if os.path.exists(path):
return path
raise Exception('No indico config found. Point the INDICO_CONFIG env var to your config file or '
'move/symlink the config in one of the following locations: {}'.format(', '.join(paths)))
def run(self, template_name, **kwargs):
template_dir = os.path.join(get_root_path('indico'), 'legacy/webinterface/tpls/latex')
template = tpl_render(os.path.join(template_dir, template_name), kwargs)
self._dir = tempfile.mkdtemp(prefix="indico-texgen-", dir=config.TEMP_DIR)
chmod_umask(self._dir, execute=True)
source_filename = os.path.join(self._dir, template_name + '.tex')
target_filename = os.path.join(self._dir, template_name + '.pdf')
log_filename = os.path.join(self._dir, 'output.log')
log_file = open(log_filename, 'a+')
with open(source_filename, 'w') as f:
f.write(template)
try:
self.run_latex(source_filename, log_file)
if self.has_toc:
self.run_latex(source_filename, log_file)
finally:
log_file.close()
if not os.path.exists(target_filename):
# something went terribly wrong, no LaTeX file was produced
raise LaTeXRuntimeException(source_filename, log_filename)
return target_filename
def _render_template(self, template_name, kwargs):
template_dir = os.path.join(get_root_path('indico'), 'legacy/pdfinterface/latex_templates')
env = Environment(loader=FileSystemLoader(template_dir),
autoescape=False,
trim_blocks=True,
keep_trailing_newline=True,
auto_reload=config.DEBUG,
extensions=[LatexEscapeExtension],
undefined=StrictUndefined,
block_start_string=r'\JINJA{', block_end_string='}',
variable_start_string=r'\VAR{', variable_end_string='}',
comment_start_string=r'\#{', comment_end_string='}')
env.filters['format_date'] = EnsureUnicodeExtension.wrap_func(format_date)
env.filters['format_time'] = EnsureUnicodeExtension.wrap_func(format_time)
env.filters['format_duration'] = lambda delta: format_human_timedelta(delta, 'minutes')
env.filters['latex'] = _latex_escape
env.filters['rawlatex'] = RawLatex
env.filters['markdown'] = kwargs.pop('markdown')
env.globals['_'] = _
env.globals['ngettext'] = ngettext
env.globals['session'] = session
template = env.get_or_select_template(template_name)
distribution = pkg_resources.get_distribution('indico-fonts')
font_dir = os.path.join(distribution.location, 'indico_fonts', '') # XXX: trailing slash required
return template.render(font_dir=font_dir, **kwargs)
def settings(self):
core_path = os.path.join(get_root_path('indico'), 'modules', 'events', 'themes.yaml')
with open(core_path) as f:
core_data = f.read()
core_settings = yaml.safe_load(core_data)
# YAML doesn't give us access to anchors so we need to include the base yaml.
# Since duplicate keys are invalid (and may start failing in the future) we
# rename them - this also makes it easy to throw them away after parsing the
# file provided by a plugin.
core_data = re.sub(r'^(\S+:)$', r'__core_\1', core_data, flags=re.MULTILINE)
for plugin, path in values_from_signal(signals.plugin.get_event_themes_files.send(), return_plugins=True):
with open(path) as f:
data = f.read()
settings = {k: v
for k, v in yaml.safe_load(core_data + '\n' + data).viewitems()
if not k.startswith('__core_')}
# We assume there's no more than one theme plugin that provides defaults.
# If that's not the case the last one "wins". We could reject this but it
# is quite unlikely that people have multiple theme plugins in the first
# place, even more so theme plugins that specify defaults.
core_settings['defaults'].update(settings.get('defaults', {}))
# Same for definitions - we assume plugin authors are responsible enough
# to avoid using definition names that are likely to cause collisions.
# Either way, if someone does this on purpose chances are good they want
# to override a default style so let them do so...
for name, definition in settings.get('definitions', {}).viewitems():
definition['plugin'] = plugin
definition.setdefault('user_visible', False)
core_settings['definitions'][name] = definition
return core_settings
def _import_plugins(self, app):
"""Imports the plugins for an application.
:param app: A Flask application
:return: A dict mapping plugin names to plugin classes
"""
state = get_state(app)
plugins = {}
for name in state.app.config['PLUGINENGINE_PLUGINS']:
entry_points = list(iter_entry_points(app.config['PLUGINENGINE_NAMESPACE'], name))
if not entry_points:
state.logger.error('Plugin {} does not exist'.format(name))
state.failed.add(name)
continue
elif len(entry_points) > 1:
state.logger.error('Plugin name {} is not unique (defined in {})'
.format(name, ', '.join(ep.module_name for ep in entry_points)))
state.failed.add(name)
continue
entry_point = entry_points[0]
try:
plugin_class = entry_point.load()
except ImportError:
state.logger.exception('Could not load plugin {}'.format(name))
state.failed.add(name)
continue
if not issubclass(plugin_class, self.plugin_class):
state.logger.error('Plugin {} does not inherit from {}'.format(name, self.plugin_class.__name__))
state.failed.add(name)
continue
plugin_class.package_name = entry_point.module_name.split('.')[0]
plugin_class.name = name
plugin_class.root_path = get_root_path(entry_point.module_name)
plugins[name] = plugin_class
return plugins
def lte(app: Flask):
for blueprint in app.blueprints.values():
blueprint.jinja_loader = jinja2.ChoiceLoader([
jinja2.FileSystemLoader(os.path.join(get_root_path('flask_admin_lte'), 'templates/lte')),
blueprint.jinja_loader,
])
app.register_blueprint(Blueprint('admin_lte', __name__, static_folder='static', static_url_path='/static/lte'))
def __init__(self, rh, event):
self._rh = rh
self.event = event
self._display_tz = self.event.display_tzinfo.zone
self._zip_file = None
self._content_dir = _normalize_path(u'OfflineWebsite-{}'.format(event.title))
self._web_dir = os.path.join(get_root_path('indico'), 'web')
self._static_dir = os.path.join(self._web_dir, 'static')
def _define_lookup():
tpl_dir = os.path.join(get_root_path('indico'), 'legacy/webinterface/tpls')
return IndicoTemplateLookup(directories=[tpl_dir],
disable_unicode=True,
input_encoding='utf-8',
default_filters=['encode_if_unicode', 'str'],
filesystem_checks=True,
imports=FILTER_IMPORTS,
cache_enabled=True)
def __init__(self, import_name, middlewares=None, loop=None, session=None):
self.import_name = import_name
self.root_path = get_root_path(import_name)
self.config = Config(self.root_path, default_config)
self._context = {}
self._loop = loop or asyncio.get_event_loop()
self._middlewares = SpiderMiddlewareManager(self, middlewares)
self._session = session or aiohttp.ClientSession(loop=self._loop)
def __init__(self, rh, event):
self._rh = rh
self.event = event
self._display_tz = self.event.display_tzinfo.zone
self._html = ""
self._fileHandler = None
self._mainPath = ""
self._staticPath = ""
self._failed_paths = set()
self._css_files = set()
self._downloaded_files = {}
self._htdocs_dir = os.path.join(get_root_path('indico'), 'htdocs')
def setup_templates(app):
'''
Takes in a Flask app and sets up the templates and staticfiles from
this project (via jinja2 loader and blueprint).
Thanks to https://github.com/lex009/flask-admin-lte for inspiration
'''
extra_template_path = os.path.join(get_root_path('flask_admin_material'), 'templates')
my_loader = jinja2.ChoiceLoader([
app.jinja_loader,
jinja2.FileSystemLoader(extra_template_path),
])
app.jinja_loader = my_loader
app.register_blueprint(Blueprint('admin_theme', __name__, static_folder='static', static_url_path='/static/admin_theme'))
return app
def run(self, dev):
self._check_root()
self._check_venv()
self._prompt_root_path(dev=dev)
self.config_dir_path = (get_root_path('indico') if dev else os.path.join(self.root_path, 'etc'))
self.config_path = os.path.join(self.config_dir_path, 'indico.conf')
self._check_configured()
self._check_directories(dev=dev)
self._prompt_indico_url(dev=dev)
self._prompt_db_uri()
self._prompt_redis_uris()
self._prompt_emails()
self._prompt_smtp_data(dev=dev)
self._prompt_defaults()
self._prompt_misc()
if not dev:
self._prompt_migration()
self._setup(dev=dev)
def discover_blueprints():
"""Discovers all blueprints inside the indico package
Only blueprints in a ``blueprint.py`` module or inside a
``blueprints`` package are loaded. Any other files are not touched
or even imported.
:return: a ``blueprints, compat_blueprints`` tuple containing two
sets of blueprints
"""
package_root = get_root_path('indico')
modules = set()
for root, dirs, files in os.walk(package_root):
for name in files:
if not name.endswith('.py') or name.endswith('_test.py'):
continue
segments = ['indico'] + os.path.relpath(root, package_root).replace(os.sep, '.').split('.') + [name[:-3]]
if segments[-1] == 'blueprint':
modules.add('.'.join(segments))
elif 'blueprints' in segments[:-1]:
if segments[-1] == '__init__':
modules.add('.'.join(segments[:-1]))
else:
modules.add('.'.join(segments))
blueprints = set()
compat_blueprints = set()
for module_name in sorted(modules):
module = import_module(module_name)
for name in dir(module):
obj = getattr(module, name)
if name.startswith('__') or not isinstance(obj, Blueprint):
continue
if obj.name.startswith('compat_'):
compat_blueprints.add(obj)
else:
blueprints.add(obj)
return blueprints, compat_blueprints
def _setup(self, dev=False):
storage_backends = {
'default': 'fs:' + os.path.join(self.data_root_path, 'archive')
}
if self.old_archive_dir:
storage_backends['legacy'] = 'fs-readonly:' + self.old_archive_dir
config_link_path = os.path.expanduser('~/.indico.conf')
if not dev:
create_config_link = _confirm(
'Create symlink?',
default=True,
help='By creating a symlink to indico.conf in {}, you can run '
'indico without having to set the INDICO_CONFIG '
'environment variable'.format(config_link_path))
else:
create_config_link = False
config_data = [
b'# General settings', b'SQLALCHEMY_DATABASE_URI = {!r}'.format(
self.db_uri.encode('utf-8')), b'SECRET_KEY = {!r}'.format(
os.urandom(32)), b'BASE_URL = {!r}'.format(
self.indico_url.encode('utf-8')),
b'CELERY_BROKER = {!r}'.format(
self.redis_uri_celery.encode('utf-8')),
b'REDIS_CACHE_URL = {!r}'.format(
self.redis_uri_cache.encode('utf-8')),
b"CACHE_BACKEND = 'redis'", b'DEFAULT_TIMEZONE = {!r}'.format(
self.default_timezone.encode('utf-8')),
b'DEFAULT_LOCALE = {!r}'.format(
self.default_locale.encode('utf-8')),
b'ENABLE_ROOMBOOKING = {!r}'.format(self.rb_active),
b'CACHE_DIR = {!r}'.format(
os.path.join(self.data_root_path, 'cache').encode('utf-8')),
b'TEMP_DIR = {!r}'.format(
os.path.join(self.data_root_path,
'tmp').encode('utf-8')), b'LOG_DIR = {!r}'.format(
os.path.join(self.data_root_path,
'log').encode('utf-8')),
b'ASSETS_DIR = {!r}'.format(
os.path.join(self.data_root_path, 'assets').encode('utf-8')),
b'STORAGE_BACKENDS = {!r}'.format({
k.encode('utf-8'): v.encode('utf-8')
for k, v in storage_backends.iteritems()
}), b"ATTACHMENT_STORAGE = 'default'",
b'ROUTE_OLD_URLS = True' if self.old_archive_dir else None, b'',
b'# Email settings', b'SMTP_SERVER = {!r}'.format(
(self.smtp_host.encode('utf-8'),
self.smtp_port)), b'SMTP_USE_TLS = {!r}'.format(
bool(self.smtp_user and self.smtp_password)),
b'SMTP_LOGIN = {!r}'.format(self.smtp_user.encode('utf-8')),
b'SMTP_PASSWORD = {!r}'.format(self.smtp_password.encode('utf-8')),
b'SUPPORT_EMAIL = {!r}'.format(self.admin_email.encode('utf-8')),
b'PUBLIC_SUPPORT_EMAIL = {!r}'.format(
self.contact_email.encode('utf-8')),
b'NO_REPLY_EMAIL = {!r}'.format(self.noreply_email.encode('utf-8'))
]
if dev:
config_data += [
b'', b'# Development options', b'DB_LOG = True',
b'DEBUG = True'
]
config = b'\n'.join(x for x in config_data if x is not None)
if dev:
if not os.path.exists(self.data_root_path):
os.mkdir(self.data_root_path)
_echo()
for path in self._missing_dirs:
_echo(
cformat('%{magenta}Creating %{magenta!}{}%{reset}%{magenta}').
format(path))
os.mkdir(path)
_echo(
cformat(
'%{magenta}Creating %{magenta!}{}%{reset}%{magenta}').format(
self.config_path))
with open(self.config_path, 'wb') as f:
f.write(config + b'\n')
package_root = get_root_path('indico')
_copy(
os.path.normpath(os.path.join(package_root,
'logging.yaml.sample')),
os.path.join(self.config_dir_path, 'logging.yaml'))
if not dev:
_link(os.path.join(package_root, 'htdocs'),
os.path.join(self.data_root_path, 'web', 'htdocs'))
_copy(os.path.join(package_root, 'web', 'indico.wsgi'),
os.path.join(self.data_root_path, 'web', 'indico.wsgi'),
force=True)
if create_config_link:
_link(self.config_path, config_link_path)
_echo()
_echo(cformat('%{green}Indico has been configured successfully!'))
if not create_config_link:
_echo(
cformat(
'Run %{green!}export INDICO_CONFIG={}%{reset} to use your config file'
).format(self.config_path))
if self.old_archive_dir:
_echo(
cformat(
'Check %{green!}https://git.io/vHP6o%{reset} for a guide on how to '
'import data from Indico v1.2'))
else:
_echo(
cformat(
'You can now run %{green!}indico db prepare%{reset} to initialize your Indico database'
))
def cli():
os.chdir(os.path.join(get_root_path('indico'), '..'))
def _get_themes_yaml(self, sender, **kwargs):
return os.path.join(get_root_path('indico_custom_themes'),
self.THEME_YAML)
def getLoggingConfigFilePath(self):
config_path = self.getFinalConfigFilePath()
if config_path is None:
return os.path.join(get_root_path('indico'), 'logging.conf.sample')
return os.path.join(os.path.dirname(config_path),
self.getLoggingConfigFile())
def configure_webpack(app):
pkg_path = os.path.dirname(get_root_path('indico'))
project = WebpackBundleProject(pkg_path, None)
app.config['WEBPACKEXT_PROJECT'] = project
app.config['WEBPACKEXT_MANIFEST_LOADER'] = IndicoManifestLoader
app.config['WEBPACKEXT_MANIFEST_PATH'] = os.path.join('dist', 'manifest.json')
def _setup(self, dev=False):
storage_backends = {'default': 'fs:' + os.path.join(self.data_root_path, 'archive')}
if self.old_archive_dir:
storage_backends['legacy'] = 'fs-readonly:' + self.old_archive_dir
config_link_path = os.path.expanduser('~/.indico.conf')
if not dev:
create_config_link = _confirm('Create symlink?', default=True,
help='By creating a symlink to indico.conf in {}, you can run '
'indico without having to set the INDICO_CONFIG '
'environment variable'.format(config_link_path))
else:
create_config_link = False
config_data = [
b'# General settings',
b'SQLALCHEMY_DATABASE_URI = {!r}'.format(self.db_uri.encode('utf-8')),
b'SECRET_KEY = {!r}'.format(os.urandom(32)),
b'BASE_URL = {!r}'.format(self.indico_url.encode('utf-8')),
b'CELERY_BROKER = {!r}'.format(self.redis_uri_celery.encode('utf-8')),
b'REDIS_CACHE_URL = {!r}'.format(self.redis_uri_cache.encode('utf-8')),
b"CACHE_BACKEND = 'redis'",
b'DEFAULT_TIMEZONE = {!r}'.format(self.default_timezone.encode('utf-8')),
b'DEFAULT_LOCALE = {!r}'.format(self.default_locale.encode('utf-8')),
b'ENABLE_ROOMBOOKING = {!r}'.format(self.rb_active),
b'CACHE_DIR = {!r}'.format(os.path.join(self.data_root_path, 'cache').encode('utf-8')),
b'TEMP_DIR = {!r}'.format(os.path.join(self.data_root_path, 'tmp').encode('utf-8')),
b'LOG_DIR = {!r}'.format(os.path.join(self.data_root_path, 'log').encode('utf-8')),
b'STORAGE_BACKENDS = {!r}'.format({k.encode('utf-8'): v.encode('utf-8')
for k, v in storage_backends.iteritems()}),
b"ATTACHMENT_STORAGE = 'default'",
b'ROUTE_OLD_URLS = True' if self.old_archive_dir else None,
b'',
b'# Email settings',
b'SMTP_SERVER = {!r}'.format((self.smtp_host.encode('utf-8'), self.smtp_port)),
b'SMTP_USE_TLS = {!r}'.format(bool(self.smtp_user and self.smtp_password)),
b'SMTP_LOGIN = {!r}'.format(self.smtp_user.encode('utf-8')),
b'SMTP_PASSWORD = {!r}'.format(self.smtp_password.encode('utf-8')),
b'SUPPORT_EMAIL = {!r}'.format(self.admin_email.encode('utf-8')),
b'PUBLIC_SUPPORT_EMAIL = {!r}'.format(self.contact_email.encode('utf-8')),
b'NO_REPLY_EMAIL = {!r}'.format(self.noreply_email.encode('utf-8'))
]
if dev:
config_data += [
b'',
b'# Development options',
b'DB_LOG = True',
b'DEBUG = True',
b'SMTP_USE_CELERY = False'
]
config = b'\n'.join(x for x in config_data if x is not None)
if dev:
if not os.path.exists(self.data_root_path):
os.mkdir(self.data_root_path)
_echo()
for path in self._missing_dirs:
_echo(cformat('%{magenta}Creating %{magenta!}{}%{reset}%{magenta}').format(path))
os.mkdir(path)
_echo(cformat('%{magenta}Creating %{magenta!}{}%{reset}%{magenta}').format(self.config_path))
with open(self.config_path, 'wb') as f:
f.write(config + b'\n')
package_root = get_root_path('indico')
_copy(os.path.normpath(os.path.join(package_root, 'logging.yaml.sample')),
os.path.join(self.config_dir_path, 'logging.yaml'))
if not dev:
_link(os.path.join(package_root, 'web', 'static'), os.path.join(self.data_root_path, 'web', 'static'))
_copy(os.path.join(package_root, 'web', 'indico.wsgi'),
os.path.join(self.data_root_path, 'web', 'indico.wsgi'),
force=True)
if create_config_link:
_link(self.config_path, config_link_path)
_echo()
_echo(cformat('%{green}Indico has been configured successfully!'))
if not dev and not create_config_link:
_echo(cformat('Run %{green!}export INDICO_CONFIG={}%{reset} to use your config file')
.format(self.config_path))
if self.old_archive_dir:
_echo(cformat('Check %{green!}https://git.io/vHP6o%{reset} for a guide on how to '
'import data from Indico v1.2'))
else:
_echo(cformat('You can now run %{green!}indico db prepare%{reset} to initialize your Indico database'))
def configure_webpack(app):
pkg_path = os.path.dirname(get_root_path('indico'))
project = WebpackBundleProject(pkg_path, None)
app.config['WEBPACKEXT_PROJECT'] = project
app.config['WEBPACKEXT_MANIFEST_LOADER'] = IndicoManifestLoader
app.config['WEBPACKEXT_MANIFEST_PATH'] = os.path.join('dist', 'manifest.json')
def _get_htdocs_path():
return os.path.join(get_root_path('indico'), 'htdocs')
def _setup(self, dev=False):
storage_backends = {
'default': 'fs:' + os.path.join(self.data_root_path, 'archive')
}
config_link_path = os.path.expanduser('~/.indico.conf')
if not dev:
create_config_link = _confirm(
'Create symlink?',
default=True,
help='By creating a symlink to indico.conf in {}, you can run '
'indico without having to set the INDICO_CONFIG '
'environment variable'.format(config_link_path))
else:
create_config_link = False
config_data = [
'# General settings', f'SQLALCHEMY_DATABASE_URI = {self.db_uri!r}',
f'SECRET_KEY = {os.urandom(32)!r}',
f'BASE_URL = {self.indico_url!r}',
f'CELERY_BROKER = {self.redis_uri_celery!r}',
f'REDIS_CACHE_URL = {self.redis_uri_cache!r}',
f'DEFAULT_TIMEZONE = {self.default_timezone!r}',
f'DEFAULT_LOCALE = {self.default_locale!r}',
f'ENABLE_ROOMBOOKING = {self.rb_active!r}',
'CACHE_DIR = {!r}'.format(
os.path.join(self.data_root_path,
'cache')), 'TEMP_DIR = {!r}'.format(
os.path.join(self.data_root_path, 'tmp')),
'LOG_DIR = {!r}'.format(os.path.join(
self.data_root_path,
'log')), 'STORAGE_BACKENDS = {!r}'.format({
k: v
for k, v in storage_backends.items()
}), "ATTACHMENT_STORAGE = 'default'", '', '# Email settings',
f'SMTP_SERVER = {(self.smtp_host, self.smtp_port)!r}',
f'SMTP_USE_TLS = {bool(self.smtp_user and self.smtp_password)!r}',
f'SMTP_LOGIN = {self.smtp_user!r}',
f'SMTP_PASSWORD = {self.smtp_password!r}',
f'SUPPORT_EMAIL = {self.admin_email!r}',
f'PUBLIC_SUPPORT_EMAIL = {self.contact_email!r}',
f'NO_REPLY_EMAIL = {self.noreply_email!r}'
]
if dev:
config_data += [
'', '# Development options', 'DB_LOG = True', 'DEBUG = True',
'SMTP_USE_CELERY = False'
]
if not self.system_notices:
config_data += [
'', '# Disable system notices', 'SYSTEM_NOTICES_URL = None'
]
config = '\n'.join(x for x in config_data if x is not None)
if dev:
if not os.path.exists(self.data_root_path):
os.mkdir(self.data_root_path)
_echo()
for path in self._missing_dirs:
_echo(
cformat('%{magenta}Creating %{magenta!}{}%{reset}%{magenta}').
format(path))
os.mkdir(path)
_echo(
cformat(
'%{magenta}Creating %{magenta!}{}%{reset}%{magenta}').format(
self.config_path))
with open(self.config_path, 'w') as f:
f.write(config + '\n')
package_root = get_root_path('indico')
_copy(
os.path.normpath(os.path.join(package_root,
'logging.yaml.sample')),
os.path.join(self.config_dir_path, 'logging.yaml'))
if not dev:
_link(os.path.join(package_root, 'web', 'static'),
os.path.join(self.data_root_path, 'web', 'static'))
_copy(os.path.join(package_root, 'web', 'indico.wsgi'),
os.path.join(self.data_root_path, 'web', 'indico.wsgi'),
force=True)
if create_config_link:
_link(self.config_path, config_link_path)
_echo()
_echo(cformat('%{green}Indico has been configured successfully!'))
if not dev and not create_config_link:
_echo(
cformat(
'Run %{green!}export INDICO_CONFIG={}%{reset} to use your config file'
).format(self.config_path))
_echo(
cformat(
'You can now run %{green!}indico db prepare%{reset} to initialize your Indico database'
))
def _get_all_locales():
# get all directories in indico/translations
root = Path(get_root_path('indico')) / 'translations'
return [ent.name for ent in root.iterdir() if ent.is_dir()]
def searchable_db_path():
return str(Path(get_root_path('tests'), 'AppData', 'searchable_db'))
def cli():
os.chdir(os.path.join(get_root_path('indico'), '..'))
# coding=utf-8
import logging
import flask
import re
import os
from settings import *
from flask import Blueprint, _request_ctx_stack
from flask.helpers import get_root_path
from werkzeug.utils import cached_property, import_string
from .exception import AppNotExist, BlueprintNotExist
from .ext.flask_config import FlaskConfig
__author__ = 'GaoJie'
config = FlaskConfig(get_root_path(__name__))
DEBUG = False
def open_debug(b):
global DEBUG
DEBUG = b
def create_app(app_name, call_back=None):
"""
根据AppName来加载app，设定配置信息，初始化app信息
"""
init_config()
if app_name not in ALLOW_APP:
raise AppNotExist(app_name, allow=False)
from pathlib import Path, PurePath
import logging
import dash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Input, Output
from flask.helpers import get_root_path
from .dash_app.account import Account
from .dash_app.layout import TAB_STYLE, TAB_SELECTED_STYLE
from .dash_app.content import (main_header, tab_balance,
tab_category_breakdown,
tab_sub_category_breakdown, tab_transaction)
logger = logging.getLogger('finances.dash_app')
ASSETS_PATH = os.path.join(get_root_path('__main__'),
r'finances\dash_app\assets')
def run_app(project_folder: str, database_name: str):
"""
Run the app
:param project_folder: folder of the project
:param database_name: name of the database
"""
database = Path(PurePath(project_folder, database_name))
account_name = 'HSBC UK' # Whren more accounts are supported, this will be selected via callback in the dash_app
account = Account(database=database, account_name=account_name)
app = dash.Dash(__name__, assets_folder=ASSETS_PATH)
app.title = 'Transactions Analysis'
app.layout = html.Div(children=[
def _get_all_locales():
# get all directories in indico/translations
return os.walk(os.path.join(get_root_path('indico'), 'translations')).next()[1]
'''
Configuration specific to development environment. Do *not* use this
configuration in production.
'''
import os
import logging
from flask.helpers import get_root_path
from psephology._util import token_urlsafe
logging.warning('Using development config. DO NOT DO THIS IN PRODUCTION.')
DEBUG = True
SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(
get_root_path('psephology'), 'db.sqlite')
SECRET_KEY = token_urlsafe()
DEBUG_TB_INTERCEPT_REDIRECTS = False
def _get_dirs(target_dir):
if not os.path.isdir(target_dir):
_echo(cformat('%{red}Directory not found:%{red!} {}').format(target_dir))
sys.exit(1)
return get_root_path('indico'), os.path.abspath(target_dir)
def make_full_path(filename):
# file_dir = os.path.dirname(os.path.realpath('__file__'))
# file_dir = sys.path[0]
file_dir = get_root_path(__name__)
full_path = os.path.join(file_dir, filename)
return full_path
def tests_root():
return get_root_path('tests')
def _get_htdocs_path():
return os.path.join(get_root_path('fossir'), 'htdocs')
def getHtdocsDir(self):
return os.path.join(get_root_path('indico'), 'htdocs')
def cli():
os.chdir(os.path.join(get_root_path('fossir'), '..'))
def create_app(test_config=None):
"""The application factory function
This function creates and configures the Flask application object. For
more on application factories, see the Flask documentation/tutorial:
http://flask.pocoo.org/docs/1.0/tutorial/factory/
http://flask.pocoo.org/docs/1.0/patterns/appfactories/
Parameters
----------
test_config : dict
A dictionary containing configuration parameters for use during unit
testing. If this parameter is `None`, the configuration will be loaded
from `config.py` in the instance folder.
Returns
-------
Flask
A flask app
"""
# create and configure the app
app = Flask(__name__,
instance_path=os.path.join(get_root_path(__name__),
'instance'),
instance_relative_config=True)
if test_config is None:
# load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
from ucsd_bisb_unofficial.models import (db, migrate, Role, get_db, Post,
WhisperPost)
from ucsd_bisb_unofficial.login import login
from ucsd_bisb_unofficial.email import mail
from ucsd_bisb_unofficial.principals import principals
from ucsd_bisb_unofficial.errors import forbidden
from ucsd_bisb_unofficial.misaka import md
from ucsd_bisb_unofficial.fts import fts
for ext in db, login, mail, principals, md, fts:
ext.init_app(app)
migrate.init_app(app, db)
login.login_view = 'auth.login'
for error, handler in ((403, forbidden), ):
app.register_error_handler(403, forbidden)
from ucsd_bisb_unofficial import (auth, blog, jumbotron, protected, lab,
career, tech, whisper, residency, ta,
search, seminars, mental_health, news,
stats, committee, gbic, fellowships,
townhall, settings, courses, td, exam,
anti_racism, outreach)
for bp in (auth.bp, blog.bp, jumbotron.bp, protected.bp, lab.bp, career.bp,
tech.bp, whisper.bp, residency.bp, ta.bp, search.bp,
seminars.bp, mental_health.bp, news.bp, stats.bp, committee.bp,
gbic.bp, fellowships.bp, townhall.bp, settings.bp, courses.bp,
td.bp, exam.bp, anti_racism.bp, outreach.bp):
app.register_blueprint(bp)
from ucsd_bisb_unofficial import uploads
app.register_blueprint(uploads.uploads_mod)
app.add_url_rule('/', endpoint='auth.login')
from ucsd_bisb_unofficial.uploads import documents, images
configure_uploads(app, documents)
configure_uploads(app, images)
@app.before_first_request
def populate_databse():
with app.app_context():
db = get_db()
db.create_all()
commit = False
for name, description in (('admin', 'site administrator'),
('whisper_user', 'whisper app user'),
('named_user', 'named user')):
if not Role.query.filter_by(name=name).first():
role = Role(name=name, description=description)
db.session.add(role)
commit = True
if commit:
db.session.commit()
@app.before_first_request
def reindex():
with app.app_context():
Post.reindex()
WhisperPost.reindex()
return app
from flask.helpers import get_root_path assets_folder = get_root_path(__name__) + '/assets/'
def _get_all_locales():
# get all directories in indico/translations
return os.walk(
os.path.join(get_root_path('indico'),
'translations')).next()[1]
def __init__(self, import_name, folder, **kwargs):
"""Initialize bundle."""
super(WebpackBundle,
self).__init__(join(get_root_path(import_name), folder),
**kwargs)
def _get_dirs(target_dir):
if not os.path.isdir(target_dir):
_echo(
cformat('%{red}Directory not found:%{red!} {}').format(target_dir))
sys.exit(1)
return get_root_path('indico'), os.path.abspath(target_dir)
def _get_htdocs_path():
return os.path.join(get_root_path('indico'), 'htdocs')
import os
from flask.helpers import get_root_path
from bitsbox._util import token_urlsafe
DEBUG = True
SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(get_root_path('bitsbox'),
'db.sqlite')
SECRET_KEY = token_urlsafe()
DEBUG_TB_INTERCEPT_REDIRECTS = False
# coding=utf-8
import logging
import flask
import re
import os
from settings import *
from flask import Blueprint, _request_ctx_stack
from flask.helpers import get_root_path
from werkzeug.utils import cached_property, import_string
from .exception import AppNotExist, BlueprintNotExist
from .ext.flask_config import FlaskConfig
__author__ = 'GaoJie'
config = FlaskConfig(get_root_path(__name__))
DEBUG = False
def open_debug(b):
global DEBUG
DEBUG = b
def create_app(app_name, call_back=None):
"""
根据AppName来加载app，设定配置信息，初始化app信息
"""
init_config()
if app_name not in ALLOW_APP:
raise AppNotExist(app_name, allow=False)
else:
def _setup(self):
storage_backends = {
'default': 'fs:' + os.path.join(self.root_path, 'archive')
}
if self.old_archive_dir:
storage_backends['legacy'] = 'fs-readonly:' + self.old_archive_dir
config_link_path = os.path.expanduser('~/.indico.conf')
create_config_link = _confirm(
'Create symlink?',
default=True,
help='By creating a symlink to indico.conf in {}, you can run '
'indico without having to set the INDICO_CONFIG '
'environment variable'.format(config_link_path))
config_data = [
b'# General settings', b'SQLAlchemyDatabaseURI = {!r}'.format(
self.db_uri.encode('utf-8')), b'SecretKey = {!r}'.format(
os.urandom(32)), b'BaseURL = {!r}'.format(
self.indico_url.encode('utf-8')),
b'CeleryBroker = {!r}'.format(
self.redis_uri_celery.encode('utf-8')),
b'RedisCacheURL = {!r}'.format(
self.redis_uri_cache.encode('utf-8')),
b"CacheBackend = 'redis'", b'DefaultTimezone = {!r}'.format(
self.default_timezone.encode('utf-8')),
b'DefaultLocale = {!r}'.format(
self.default_locale.encode('utf-8')),
b'IsRoomBookingActive = {!r}'.format(self.rb_active),
b'CacheDir = {!r}'.format(
os.path.join(self.root_path, 'cache').encode('utf-8')),
b'TempDir = {!r}'.format(
os.path.join(self.root_path,
'tmp').encode('utf-8')), b'LogDir = {!r}'.format(
os.path.join(self.root_path,
'log').encode('utf-8')),
b'AssetsDir = {!r}'.format(
os.path.join(self.root_path, 'assets').encode('utf-8')),
b'StorageBackends = {!r}'.format({
k.encode('utf-8'): v.encode('utf-8')
for k, v in storage_backends.iteritems()
}), b"AttachmentStorage = 'default'",
b'RouteOldURLs = True' if self.old_archive_dir else None, b'',
b'# Email settings', b'SmtpServer = {!r}'.format(
(self.smtp_host.encode('utf-8'),
self.smtp_port)), b'SmtpUseTLS = {!r}'.format(
bool(self.smtp_user
and self.smtp_password)), b'SmtpLogin = {!r}'.format(
self.smtp_user.encode('utf-8')),
b'SmtpPassword = {!r}'.format(self.smtp_password.encode('utf-8')),
b'SupportEmail = {!r}'.format(self.admin_email.encode('utf-8')),
b'PublicSupportEmail = {!r}'.format(
self.contact_email.encode('utf-8')),
b'NoReplyEmail = {!r}'.format(self.noreply_email.encode('utf-8'))
]
config = b'\n'.join(x for x in config_data if x is not None)
_echo()
for path in self._missing_dirs:
_echo(
cformat('%{magenta}Creating %{magenta!}{}%{reset}%{magenta}').
format(path))
os.mkdir(path)
_echo(
cformat(
'%{magenta}Creating %{magenta!}{}%{reset}%{magenta}').format(
self.config_path))
with open(self.config_path, 'wb') as f:
f.write(config + b'\n')
package_root = get_root_path('indico')
_copy(
os.path.normpath(os.path.join(package_root,
'logging.conf.sample')),
os.path.join(self.root_path, 'etc', 'logging.conf'))
_link(os.path.join(package_root, 'htdocs'),
os.path.join(self.root_path, 'web', 'htdocs'))
_copy(os.path.join(package_root, 'web', 'indico.wsgi'),
os.path.join(self.root_path, 'web', 'indico.wsgi'),
force=True)
if create_config_link:
_link(self.config_path, config_link_path)
_echo()
_echo(cformat('%{green}Indico has been configured successfully!'))
if not create_config_link:
_echo(
cformat(
'Run %{green!}export INDICO_CONFIG={}%{reset} to use your config file'
).format(self.config_path))
if self.old_archive_dir:
_echo(
cformat(
'Check %{green!}https://git.io/vHP6o%{reset} for a guide on how to '
'import data from Indico v1.2'))
else:
_echo(
cformat(
'You can now run %{green!}indico db prepare%{reset} to initialize your Indico database'
))
def register_dashapps(app):
# Split file into layout and callbacks scripts:
from app.scada_stg1.layout import layout
from app.scada_stg1.callbacks import register_callbacks
# Meta tags for viewport responsiveness:
meta_viewport = {
"name": "viewport",
"content": "width=device-width, initial-scale=1, shrink-to-fit=no"
}
layout_ess = [
'https://cdn.rawgit.com/plotly/dash-app-stylesheets/2d266c578d2a6e8850ebce48fdb52759b2aef506/stylesheet-oil-and-gas.css'
]
scada_stg1 = dash.Dash(__name__,
server=app,
url_base_pathname='/scada_stg1/',
assets_folder=get_root_path(__name__) +
'/dashboard/assets/',
meta_tags=[meta_viewport],
external_stylesheets=layout_ess)
scada_stg1.title = 'Scada Stg1'
scada_stg1.layout = layout
register_callbacks(scada_stg1)
# Use Flask login security:
# _protect_dashviews(scada_stg1)
inv_stg2 = dash.Dash(__name__,
server=app,
url_base_pathname='/inv_stg2/',
assets_folder=get_root_path(__name__) +
'/dashboard/assets/',
meta_tags=[meta_viewport],
external_stylesheets=layout_ess)
inv_stg2.title = 'Inverter Stg2'
inv_stg2.layout = layout
register_callbacks(inv_stg2)
dte_stg3 = dash.Dash(__name__,
server=app,
url_base_pathname='/dte_stg3/',
assets_folder=get_root_path(__name__) +
'/dashboard/assets/',
meta_tags=[meta_viewport],
external_stylesheets=layout_ess)
dte_stg3.title = 'DownTime Stg3'
dte_stg3.layout = layout
register_callbacks(dte_stg3)
fact_stg4 = dash.Dash(__name__,
server=app,
url_base_pathname='/fact_stg4/',
assets_folder=get_root_path(__name__) +
'/dashboard/assets/',
meta_tags=[meta_viewport],
external_stylesheets=layout_ess)
fact_stg4.title = 'Fact Stg4'
fact_stg4.layout = layout
register_callbacks(fact_stg4)
