class Application(web.Application):
def __init__(self):
from handlers import routes
settings = dict(
debug=options.debug,
static_path=os.path.join(os.path.dirname(__file__), "static"),
static_url_prefix=options.static_url_prefix,
cookie_secret=options.cookie_secret,
xsrf_cookies=True,
login_url=options.login_url,
)
super(Application, self).__init__(routes, **settings)
template_path = os.path.join(os.path.dirname(__file__), "templates"),
self.env = Environment(
loader=FileSystemLoader(template_path),
extensions=[
'jinja2.ext.i18n', 'lib.jinja2htmlcompress.HTMLCompress'
],
)
#Custom Filters
self.env.filters = {
'datetimeformat': datetimeformat,
'mdconvert': mdconvert,
'get_cover': get_cover,
'get_status': get_status,
}
self.env.install_null_translations(newstyle=True)
self.env.globals['cfg'] = settings
logging.info("load finished!")
class Application(tornado.web.Application):
def __init__(self):
static_path = join(dirname(__file__), 'static')
handlers = (
(r'/', Index),
(r'/feeds/edit/([0-9]+)/?', FeedEdit),
(r'/feeds/delete/([0-9]+)/?', FeedDelete),
(r'/feeds/add/?', FeedAdd),
(r'/refresh/?', Refresh),
(r'/mark_as_read/?', MarkAsRead),
(r'/static/(.*)',
tornado.web.StaticFileHandler,
{'path': static_path}),
(r'/.*$', NoDestinationHandler)
)
settings = dict(
title='Huluobo',
debug=isfile(join(dirname(__file__), 'debug')),
xsrf_cookies=True,
static_path=static_path,
cookie_secret=cookie_secret
)
logger = logging.getLogger('huluobo')
if settings['debug']:
logger.setLevel(logging.DEBUG)
template_path = join(dirname(__file__), 'templates')
tornado.web.Application.__init__(self, handlers, **settings)
self.env = Environment(loader=FileSystemLoader(template_path),
extensions=['jinja2.ext.i18n'])
self.env.install_null_translations(newstyle=True)
self.env.globals['cfg'] = settings
class Application(web.Application):
def __init__ (self):
from handlers import routes
settings = dict(
debug = options.debug,
static_path = os.path.join(os.path.dirname(__file__), "static"),
static_url_prefix = options.static_url_prefix,
cookie_secret = options.cookie_secret,
xsrf_cookies = True,
login_url = options.login_url,
)
super(Application, self).__init__(routes, **settings)
template_path = os.path.join(os.path.dirname(__file__), "templates"),
self.env = Environment(
loader=FileSystemLoader(template_path),
extensions = ['jinja2.ext.i18n',
'lib.jinja2htmlcompress.HTMLCompress'
],
)
#Custom Filters
self.env.filters = {
'datetimeformat' : datetimeformat,
'mdconvert' : mdconvert,
'get_cover' : get_cover,
'get_status' : get_status,
}
self.env.install_null_translations(newstyle=True)
self.env.globals['cfg'] = settings
logging.info("load finished!")
def create_jinja2_environment(language):
env = Environment(loader=FileSystemLoader('layouts'),
extensions=['jinja2.ext.i18n'])
if language == 'ru':
translations = gettext.GNUTranslations(open('messages.mo'))
env.install_gettext_translations(translations, newstyle=True)
elif language == 'en':
env.install_null_translations(newstyle=False)
env.globals.update(url_for=url_for, LANGUAGE=language)
return env
def environment(**options):
env = Environment(**options)
env.globals.update({
'static': static,
'url': resolve_url,
'webpack_scripts': webpack_scripts,
'webpack_styles': webpack_styles,
})
# jinja2.ext.i18n
env.install_null_translations(newstyle=True)
return env
def render_page(movies, output=None, title="", urlprefix=""):
""" Render the movies list to specified output """
env = Environment(extensions=['jinja2.ext.i18n'])
env.install_null_translations()
with open(TEMPLATE_PATH) as tpl:
template = env.from_string(tpl.read().decode('utf-8'))
# Default output is stdout
out = sys.stdout
if output:
out = open(output, 'w')
page = template.render(movies=movies, title=title, urlprefix=urlprefix)
out.write(page.encode('ascii', 'xmlcharrefreplace'))
out.close()
def environment(**options):
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': url,
'assets': assets,
# 'gravatar_url': get_avatar_url,
'get_current_language': get_language,
'get_available_languages': get_available_languages,
'get_language_info_list': get_language_info_list,
# 'switch': gargoyle.is_active,
# 'avatar_url': avatar_url
})
env.filters.update(
datetimeformat=babel.datetimefmt,
dateformat=babel.datefmt,
timeformat=babel.timefmt,
natural_period=natural_period,
# timedeltaformat=format_timedelta,
numberformat=babel.numberfmt,
decimalformat=babel.decimalfmt,
currencyformat=babel.currencyfmt,
percentformat=babel.percentfmt,
scientificformat=babel.scientificfmt,
append_get=do_append_get,
class_name=do_class_name,
)
env.add_extension('jinja2.ext.loopcontrols')
env.add_extension('jinja2.ext.with_')
env.add_extension('dinja2.ext.active')
# from ext.relative_templates import RelativeInclude
# env.add_extension(RelativeInclude)
# env.add_extension('jinja2_highlight.HighlightExtension')
# env.add_extension('jinja2htmlcompress.HTMLCompress')
env.add_extension('webassets.ext.jinja2.AssetsExtension')
env.assets_environment = get_env()
env.add_extension('jinja2.ext.i18n')
if settings.USE_I18N:
from django.utils import translation
env.install_gettext_translations(translation, newstyle=True)
else: # pragma: no cover
env.install_null_translations(newstyle=True)
return env
def create_jinja2_environment(language):
env = Environment(loader=FileSystemLoader('layouts'),
extensions=['jinja2.ext.i18n'])
if language == 'ru':
translations = gettext.GNUTranslations(open('messages.mo'))
env.install_gettext_translations(translations, newstyle=True)
# Hack:
globals_gettext = env.globals['gettext']
env.globals['gettext'] = contextfunction(
lambda context, s: unicode(globals_gettext(context, s).decode('utf-8')))
elif language == 'en':
env.install_null_translations(newstyle=False)
env.globals.update(url_for=url_for, LANGUAGE=language)
return env
def init_env(self):
# autoescape=False to allow injecting html entities from translated text
env = Environment(
loader=PackageLoader("warc2zim", "templates"),
extensions=["jinja2.ext.i18n"],
autoescape=False,
)
try:
env.install_gettext_translations(Locale.translation)
except OSError:
logger.warning(
"No translations table found for language: {0}".format(
self.language))
env.install_null_translations()
return env
class Renderer:
def __init__(self, content_dir='../../content/', output_dir='../../static/html'):
loader = FileSystemLoader(searchpath='templates')
self.defaults = {'translations': {}, 'sections': {'en': [], 'fr': []}}
self.env = Environment(loader=loader, extensions=['jinja2.ext.i18n'])
self.translations = {
'en': gettext.translation('jvk', 'locales', languages=['en']),
'fr': gettext.translation('jvk', 'locales', languages=['fr']),
}
self.env.install_null_translations()
self.queue = []
self.content_dir = content_dir
self.output_dir = output_dir
def read_content(self, source):
with open(self.content_dir + source) as content_file:
return content_file.read()
def add(self, path, *args, **kwargs):
if 'section' in kwargs and kwargs['section']:
lang = kwargs['lang']
section = {'href': path,
'title': kwargs['title']}
try:
section.update(kwargs['section'])
except:
pass
self.defaults['sections'][lang].append(section)
args = tuple([path]+list(args))
self.queue.append((args, kwargs))
def render_all(self):
for args, kwargs in self.queue:
if 'lang' in kwargs:
translations = self.translations[kwargs['lang']]
self.env.install_gettext_translations(translations)
self.render(*args, **kwargs)
def render(self, path, template, **kwargs):
kwargs = {**self.defaults, **kwargs}
page = self.env.get_template(template).render(path=path, **kwargs)
with open(self.output_dir + path + '.html', 'w') as out:
out.write(page)
class Renderer:
def __init__(self,
content_dir='../../content/',
output_dir='../../static/html'):
loader = FileSystemLoader(searchpath='templates')
self.defaults = {'translations': {}, 'sections': {'en': [], 'fr': []}}
self.env = Environment(loader=loader, extensions=['jinja2.ext.i18n'])
self.translations = {
'en': gettext.translation('jvk', 'locales', languages=['en']),
'fr': gettext.translation('jvk', 'locales', languages=['fr']),
}
self.env.install_null_translations()
self.queue = []
self.content_dir = content_dir
self.output_dir = output_dir
def read_content(self, source):
with open(self.content_dir + source) as content_file:
return content_file.read()
def add(self, path, *args, **kwargs):
if 'section' in kwargs and kwargs['section']:
lang = kwargs['lang']
section = {'href': path, 'title': kwargs['title']}
try:
section.update(kwargs['section'])
except:
pass
self.defaults['sections'][lang].append(section)
args = tuple([path] + list(args))
self.queue.append((args, kwargs))
def render_all(self):
for args, kwargs in self.queue:
if 'lang' in kwargs:
translations = self.translations[kwargs['lang']]
self.env.install_gettext_translations(translations)
self.render(*args, **kwargs)
def render(self, path, template, **kwargs):
kwargs = {**self.defaults, **kwargs}
page = self.env.get_template(template).render(path=path, **kwargs)
with open(self.output_dir + path + '.html', 'w') as out:
out.write(page)
def create_env():
"""Create a new Jinja2 environment."""
searchpath = list(settings.TEMPLATE_DIRS)
env = Environment(loader=FileSystemLoader(searchpath),
auto_reload=settings.TEMPLATE_DEBUG,
cache_size=getattr(settings, 'JINJA2_CACHE_SIZE', 50),
extensions=getattr(settings, 'JINJA2_EXTENSIONS', ()))
filters = getattr(settings, 'JINJA2_FILTERS', ())
globals = getattr(settings, 'JINJA2_GLOBALS', ())
env.filters.update(load_filters(filters))
env.globals.update(load_globals(globals))
try:
translations = gettext.translation(getattr(settings, 'GETTEXT_DOMAIN', 'django'),
getattr(settings, 'LOCALE_DIR', './locale/ '))
env.install_gettext_translations(translations)
except:
env.install_null_translations()
return env
def configure_env(self):
"""Configure template env
"""
searchpath = list(self.config.get("TEMPLATES_PATH", 'templates'))
env = Environment(loader=FileSystemLoader(searchpath),
auto_reload=self.config.get('TEMPLATE_DEBUG_RELOAD', False),
cache_size=self.config.get('JINJA2_CACHE_SIZE', 50),
extensions=self.config.get('JINJA2_EXTENSIONS', ()))
filters = self.config.get('JINJA2_FILTERS', ())
globals = self.config.get('JINJA2_GLOBALS', ())
env.filters.update(load_filters(filters))
env.globals.update(load_globals(globals))
try:
env.install_gettext_translations()
except Exception:
env.install_null_translations()
return env
def configure_env(self):
"""Configure template env
"""
searchpath = list(self.config.get("TEMPLATES_PATH", 'templates'))
env = Environment(loader=FileSystemLoader(searchpath),
auto_reload=self.config.get('TEMPLATE_DEBUG_RELOAD',
False),
cache_size=self.config.get('JINJA2_CACHE_SIZE', 50),
extensions=self.config.get('JINJA2_EXTENSIONS', ()))
filters = self.config.get('JINJA2_FILTERS', ())
globals = self.config.get('JINJA2_GLOBALS', ())
env.filters.update(load_filters(filters))
env.globals.update(load_globals(globals))
try:
env.install_gettext_translations()
except Exception:
env.install_null_translations()
return env
class Application(tornado.web.Application):
def __init__ (self):
settings = dict(
debug=options.debug,
autoescape=options.autoescape,
cookie_secret=options.cookie_secret,
xsrf_cookies=True,
login_url=options.login_url,
template_path=options.template_path,
static_path=options.static_path,
static_url_prefix=options.static_url_prefix,
)
from bz.routes import handlers
super(Application, self).__init__(handlers, **settings)
# init db & cache
from bz.data import db, cache
Application.db = db.session
Application.cache = cache
# load template
from jinja2 import Environment, FileSystemLoader
self.env = Environment(loader=FileSystemLoader(options.template_path), extensions = [
'jinja2.ext.i18n',
'bz.lib.jinja2htmlcompress.HTMLCompress'])
#Custom Filters
self.env.filters = {
}
self.env.install_null_translations(newstyle=True)
self.env.globals['cfg'] = settings
import bz
logging.info("load finished, version %s" % bz.__version__ )
class ServiceManager(object):
implements(IServiceMaker, IPlugin)
tapname = "gitlab-webhook-xmpp"
description = "GitLab push event XMPP notification web hook."
options = Options
mucHandlers = []
def makeService(self, options):
"""
Make services to handle push event notifications.
"""
# check confguration file is specified and exists
if not options["config"]:
raise ValueError('Configuration file not specified (try to check --help option)')
cfgFileName = options["config"];
if not os.path.isfile(cfgFileName):
raise ValueError('Configuration file not found:', cfgFileName)
# read configuration file
cfg = ConfigParser()
cfg.read(cfgFileName)
# create Twisted application
application = service.Application("gitlab-webhook-xmpp")
serviceCollection = service.IServiceCollection(application)
# create XMPP client
client = XMPPClient(JID(cfg.get('xmpp', 'jid')), cfg.get('xmpp', 'password'))
# client.logTraffic = True
client.setServiceParent(application)
# join to all MUC rooms
nickname = cfg.get('xmpp', 'nickname') if cfg.has_option('xmpp', 'nickname') else DEFAULT_NICKNAME
notifications = cfg.items('notifications')
for room, repositoryMasks in notifications:
mucHandler = MUCHandler(JID(room), nickname, repositoryMasks.split(','))
mucHandler.setHandlerParent(client)
self.mucHandlers.append(mucHandler)
templateLoader = None
if cfg.has_option('message', 'template'):
templateFullName = cfg.get('message', 'template')
templatePath, self.templateName = os.path.split(templateFullName)
templateLoader = FileSystemLoader(templatePath)
else:
self.templateName = DEFAULT_TEMPLATE_NAME
templateLoader = PackageLoader('xmpp_webhook', 'templates')
self.templateEnvironment = Environment(loader=templateLoader, extensions=['jinja2.ext.i18n'])
self.templateEnvironment.install_null_translations() # use i18n to pluralize only
# create web hook handler
rootHttpResource = Resource()
rootHttpResource.putChild('', WebHookHandler(self))
site = server.Site(rootHttpResource)
httpPort = cfg.getint('http', 'port') if cfg.has_option('http', 'port') else DEFAULT_HTTP_PORT
httpServer = internet.TCPServer(httpPort, site)
httpServer.setServiceParent(serviceCollection)
return serviceCollection
def notifyPush(self, pushData):
"""
Send message with push data to all XMPP handlers matching repository URL
"""
repositoryUrl = pushData.get('repository').get('url')
template = self.templateEnvironment.get_template(self.templateName)
for mucHandler in self.mucHandlers:
if mucHandler.matchRepositoryMask(repositoryUrl):
mucHandler.sendMessage(template.render(push=pushData))
class ServiceManager(object):
implements(IServiceMaker, IPlugin)
tapname = "gitlab-webhook-xmpp"
description = "GitLab push event XMPP notification web hook."
options = Options
mucHandlers = []
def makeService(self, options):
"""
Make services to handle push event notifications.
"""
# check confguration file is specified and exists
if not options["config"]:
raise ValueError(
'Configuration file not specified (try to check --help option)'
)
cfgFileName = options["config"]
if not os.path.isfile(cfgFileName):
raise ValueError('Configuration file not found:', cfgFileName)
# read configuration file
cfg = ConfigParser()
cfg.read(cfgFileName)
# create Twisted application
application = service.Application("gitlab-webhook-xmpp")
serviceCollection = service.IServiceCollection(application)
# create XMPP client
client = XMPPClient(JID(cfg.get('xmpp', 'jid')),
cfg.get('xmpp', 'password'))
# client.logTraffic = True
client.setServiceParent(application)
# join to all MUC rooms
nickname = cfg.get('xmpp', 'nickname') if cfg.has_option(
'xmpp', 'nickname') else DEFAULT_NICKNAME
notifications = cfg.items('notifications')
for room, repositoryMasks in notifications:
mucHandler = MUCHandler(JID(room), nickname,
repositoryMasks.split(','))
mucHandler.setHandlerParent(client)
self.mucHandlers.append(mucHandler)
templateLoader = None
if cfg.has_option('message', 'template'):
templateFullName = cfg.get('message', 'template')
templatePath, self.templateName = os.path.split(templateFullName)
templateLoader = FileSystemLoader(templatePath)
else:
self.templateName = DEFAULT_TEMPLATE_NAME
templateLoader = PackageLoader('xmpp_webhook', 'templates')
self.templateEnvironment = Environment(loader=templateLoader,
extensions=['jinja2.ext.i18n'])
self.templateEnvironment.install_null_translations(
) # use i18n to pluralize only
# create web hook handler
rootHttpResource = Resource()
rootHttpResource.putChild('', WebHookHandler(self))
site = server.Site(rootHttpResource)
httpPort = cfg.getint('http', 'port') if cfg.has_option(
'http', 'port') else DEFAULT_HTTP_PORT
httpServer = internet.TCPServer(httpPort, site)
httpServer.setServiceParent(serviceCollection)
return serviceCollection
def notifyPush(self, pushData):
"""
Send message with push data to all XMPP handlers matching repository URL
"""
repositoryUrl = pushData.get('repository').get('url')
kind = pushData.get('object_kind')
if kind == 'push':
template_name = 'message_push.txt'
elif kind == 'issue':
template_name = 'message_issue.txt'
elif kind == 'merge_request':
template_name = 'message_mr.txt'
elif kind == 'note':
type_ = pushData.get('object_attributes').get('noteable_type')
if type_ == 'Issue':
template_name = 'message_note_issue.txt'
elif type_ == 'MergeRequest':
template_name = 'message_note_mr.txt'
elif type_ == 'Commit':
template_name = 'message_note_commit.txt'
else:
return
else:
return
template = self.templateEnvironment.get_template(template_name)
for mucHandler in self.mucHandlers:
if mucHandler.matchRepositoryMask(repositoryUrl):
mucHandler.sendMessage(template.render(push=pushData))
class DjangoKit(Kit):
"""Magic wrapper for jinja environment for django
"""
def __init__(self, settings, loader=FileSystemLoader):
self.settings = settings
self.search_path = getattr(settings, 'TEMPLATE_DIRS', list())
self.loader = import_string(getattr(settings, 'TEMPLATE_LOADER',
'jinja2.FileSystemLoader'))
if getattr(settings, "JINJA2_BYTECODE_CACHE", False):
self.bytecode_cache = import_string(getattr(settings, 'JINJA2_BYTECODE_CACHE'))
else:
self.bytecode_cache = None
self.env = Environment(loader=self.loader(self.search_path),
auto_reload=getattr(settings, 'JINJA2_AUTO_RELOAD', False),
cache_size=getattr(settings, 'JINJA2_CHACHE_SIZE', 50),
extensions=getattr(settings, 'JINJA2_EXTENSIONS', ()),
bytecode_cache=self.bytecode_cache)
self.filters = getattr(settings, 'JINJA2_FILTERS', [])
self.globals = getattr(settings, 'JINJA2_GLOBALS', [])
# Not good :-(
for name, f in self.load_filters(self.filters).iteritems():
self.add_filter(f, name)
for name, f in self.load_globals(self.globals).iteritems():
self.add_global(f, name)
if getattr(settings, 'USE_I18N'):
try:
self.env.install_gettext_translations(translation)
except Exception:
self.env.install_null_translations()
def get_standard_processors(self):
"""Get django standart processors
"""
try:
from django.template.context import get_standard_processors
return get_standard_processors()
except Exception:
return []
def render_to_string(self, template_name, context=None, request=None,
processors=None):
return super(DjangoKit, self).render_to_string(
template_name, context=context, processors=processors,
processor_arg=request)
def render_to_response(self, template_name, context=None, request=None,
processors=None, mimetype=None,
response_class=HttpResponse):
"""Return http response
"""
if 'request' not in context:
context['request'] = request
return response_class(self.render_to_string(
template_name, context=context,
processors=processors, request=request),
mimetype=mimetype)
class HTMLPage(Page, metaclass=Singleton):
"""
Base class for HTML UI pages.
Class Attributes:
_tpl (SharedData): Descriptor object that handles access to Jinja2 template environment.
Also see `Page.__doc__`
"""
_tpl = SharedData('_tpl')
_tpl_setup_ran = SharedData('_tpl_setup_running')
_top_level_tabs = SharedData('_top_level_tabs')
def __init__(self, name='HTMLPage', index=0, tpl_engine='jinja', *args, **kwargs):
"""
Attributes:
_tpl (Environment): The Jinja2 template environment.
Also see `Page.__doc__`.
Args:
name (str): A name for this widget.
"""
super().__init__(name=name, tpl_engine=tpl_engine, *args, **kwargs)
self.signals = ['go-to-next-page', '--trigger-event']
self.tabs = []
self.can_go_to_next_page = False
self.index = index
self.logger.debug('page index is %s', index)
if self._tpl is None and self._tpl_setup_ran is None:
self._tpl_setup_ran = True
self._initialize_template_engine()
if self._pages_data is None:
self.logger.debug('creating data object in _pages_data for %s..', name)
self._pages_data = DataObject()
if self._top_level_tabs is None:
self.logger.debug('Generating main navigation tabs list..')
self._generate_tabs_list()
self._initialize_page_data()
def _create_and_connect_signals(self):
"""
Creates the page's signals and connects them to their callbacks (handlers).
Signals should be appended to `self.signals` prior to calling this method.
A corresponding result signal will be created for each signal and added to the
allowed signals list automatically. Signal names will have 'do-' prepended to them.
Their corresponding result signal will have '-result' appended to it.
The name of the callback method that will be registered for each signal will be the
signal name as it appears in `self.signals` at the time of calling this method with
hyphens replaced by underscores and should end with '_cb'.
A callback is not automatically connected for signals that start with two hyphens.
Example:
>>> self.signals = ['some-action', 'some-other-action', '--private-action']
>>> self._create_and_connect_signals()
>>> self.signals
['do-some-action', 'some-action-result', 'do-other-action',
'other-action-result', 'private-action']
With the above, these callback methods will have been registered (they must exist):
'do-some-action': `self.some_action_cb`
'do-other-action': `self.other_action_cb`
"""
signals = []
for _signal in self.signals:
result_signal_name = '{}-result'.format(_signal)
signal_name = 'do-{}'.format(_signal) if not _signal.startswith('--') else _signal[2:]
signals_to_add = [
s for s in [signal_name, result_signal_name]
if s not in self._allowed_signals
]
for name in signals_to_add:
self._allowed_signals.append(name)
self._main_window.create_custom_signal(name)
signals.append(name)
if not _signal.startswith('--'):
callback_name = '{}_cb'.format(_signal.replace('-', '_'))
callback = getattr(self, callback_name)
self._main_window.connect(signal_name, callback)
self.signals = signals
def _generate_tabs_list(self):
tabs = self._pages_helper.get_page_names()
excluded = ['language', 'welcome']
self._top_level_tabs = [t for t in tabs if t not in excluded]
def _get_default_template_vars(self):
return {
'page_name': self.name,
'top_level_tabs': self._get_top_level_tabs(),
'page_index': self.index
}
def _get_initial_page_data(self):
return dict()
def _get_top_level_tabs(self):
return [(t, self.name == t) for t in self._top_level_tabs]
def _initialize_template_engine(self):
resources_path = 'cnchi://{}'.format(os.path.join(self.PAGES_DIR, 'resources'))
tpl_map = {
pdir: FileSystemLoader(os.path.join(self.PAGES_DIR, pdir)) for pdir in self._page_dirs
}
tpl_map['pages'] = FileSystemLoader(self.PAGES_DIR)
self._tpl = Environment(loader=PrefixLoader(tpl_map), lstrip_blocks=True, trim_blocks=True)
self._tpl.globals['RESOURCES_DIR'] = resources_path
self._tpl.add_extension('jinja2.ext.do')
self._tpl.add_extension('jinja2.ext.i18n')
self._tpl.install_null_translations(newstyle=True)
def _initialize_page_data(self):
if getattr(self._pages_data, self.name) is None:
from_dict = self._get_initial_page_data()
setattr(self._pages_data, self.name, DataObject(from_dict=from_dict))
def emit_js(self, name, *args):
""" See `Controller.emit_js.__doc__` """
self._controller.emit_js(name, *args)
def get_next_page_index(self):
return self._pages_helper.page_names.index(self.name) + 1
def get_previous_page_index(self):
return self._pages_helper.page_names.index(self.name) - 1
def go_to_next_page(self, obj=None, next_plus=0):
if self.name != self._controller.current_page:
return
self.store_values()
self._controller.set_current_page(self.get_next_page_index() + next_plus)
return True
def go_to_next_page_cb(self, obj=None, next_plus=0):
self.go_to_next_page(obj, next_plus)
def prepare(self):
""" This must be implemented by subclasses """
pass
def render_template(self, name=None, tpl_vars=None):
name = name if name is not None else self.template
default_tpl_vars = self._get_default_template_vars()
tpl = self._tpl.get_template(name)
if tpl_vars is not None:
tpl_vars = tpl_vars.update(default_tpl_vars)
else:
tpl_vars = default_tpl_vars
return tpl.render(tpl_vars)
def render_template_as_bytes(self, name=None, tpl_vars=None):
tpl = self.render_template(name=name, tpl_vars=tpl_vars)
return tpl.encode('UTF-8')
def store_values(self):
""" This must be implemented by subclasses """
self._pages_data.has_data = True
from os import path
from zine import environment
from zine.config import Configuration
from zine.api import db
from zine.config import ConfigurationTransactionError
from zine.utils.crypto import gen_pwhash, gen_secret_key, new_iid
from zine.utils.validators import is_valid_email, check
from zine.i18n import load_core_translations, has_language, list_languages
from werkzeug import Request, Response, redirect
from jinja2 import Environment, FileSystemLoader
template_path = path.join(path.dirname(__file__), 'templates')
jinja_env = Environment(loader=FileSystemLoader(template_path),
extensions=['jinja2.ext.i18n'])
jinja_env.install_null_translations()
#: header for the config file
CONFIG_HEADER = '''\
# Zine configuration file
# This file is also updated by the Zine admin interface.
# The charset of this file must be utf-8!
'''
def render_response(request, template_name, context):
context.update(
gettext=request.translations.gettext,
ngettext=request.translations.ngettext,
class Prototype(object):
def __init__(self):
self.project_path = os.getcwd()
self.source_path = os.path.join(self.project_path, 'source')
self.build_path = os.path.join(self.project_path, 'build')
self.template_path = os.path.join(self.project_path, 'source',
'layouts')
try:
config_path = os.path.join(self.project_path, 'config.json')
config = open(config_path, 'r')
self.config = json.load(config)
except Exception as e:
print('Fatal Error: config.json missing or corrupt.')
raise
self.translations_key = self.config.get('translations_key', '')
self.port = self.config.get('port', 2000)
# create static file handlers for all sub folders of the source directory
# a static file handler has the following format
#
# (r"/css/(.*)", StaticFileHandler, {"path": os.path.join(self.source_path, 'css')})
handlers = []
level = 1
for root, folders, files in os.walk(self.source_path):
if level > 0:
for folder in folders:
handlers.append(
(r"/%s/(.*)" % (folder), StaticFileHandler, {
"path": os.path.join(self.source_path, folder)
}))
else:
break
level -= 1
handlers += [
(r"/(?P<language>[a-z]{2}|[a-z]{2}_[A-Z]{2})/.*",
TranslatedHandler),
(r"/.*", DefaultHandler),
]
# set up tornado web application
self.application = Application(handlers)
# set up jinja template loader
template_loader = FileSystemLoader(searchpath=self.source_path)
self.jinja_environment = Environment(
loader=template_loader,
extensions=['jinja2.ext.i18n'],
)
self.jinja_environment.globals['asset'] = self.asset
def runserver(self, port=None):
"""
run the tornado web server and watch for sass changes
"""
if port == None:
port = self.port
try:
# watch for sass changes
pylibsass.watch(os.path.join(self.source_path, 'scss'),
os.path.join(self.source_path, 'css'))
# setup the server
tornado.autoreload.add_reload_hook(self.reload_hook)
tornado.autoreload.start()
self.application.listen(port)
print('now serving on port %s...' % port)
tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt as e:
pass
except socket.error:
print('port %s is already in use.' % (port))
def asset(self, filename, cachebuster=False):
"""
for jinja templates, returns the asset specified and optionally applies the cachebuster
"""
if cachebuster:
return filename + '?ver=' + str(random.getrandbits(10))
else:
return filename
def full_asset_path(self, filename, cachebuster=False):
"""
Returns the absolute file path of an asset
"""
if self.config.get('build_path') or self.config.get(
'build_path') == '':
path = self.config['build_path']
else:
path = self.current_path
if filename[0] == '/':
filename = filename[1:]
return os.path.join(path, filename)
def render_html(self, uri, **kwargs):
"""
returns HTML document as a string
"""
print('Render HTML :: {}'.format(uri))
path = self.source_path
language = kwargs.get('language', False)
build = kwargs.get('build', False)
# load the translations
try:
if language:
language = [language.replace('-', '_')]
locale_path = os.path.join(self.project_path, 'translations')
translations_path = gettext.find(self.translations_key,
locale_path, language)
translations = gettext.translation(self.translations_key,
locale_path,
language,
fallback=False)
else:
translations = False
except Exception as e:
self.handle_generic_exception(e, 'Error loading translations')
# try to get rendered HTML
try:
if build:
path = self.build_path
if language:
path = os.path.join(path, language[0])
self.current_path = path
if build:
self.jinja_environment.globals['asset'] = self.full_asset_path
if translations:
self.jinja_environment.install_gettext_translations(
translations, newstyle=True)
else:
self.jinja_environment.install_null_translations()
# load the file
template_file = uri.replace(path, '')
try:
template = self.jinja_environment.get_template(template_file)
except TemplateNotFound as e:
print('Cannot locate template {}'.format(template_file))
return ''
# load data from data folder into custom_data dictionary
custom_data = {}
for root, folders, files in os.walk(os.path.join(
self.project_path, self.config['data']),
topdown=False):
for name in files:
try:
fe = open(os.path.join(root, name))
loaded = json.load(fe)
custom_data[name] = loaded
except Exception as e:
self.handle_generic_exception(e, 'Error loading data')
# template.render() returns a string which contains the rendered html
language = language[0] if type(language) == list else 'en_US'
html_output = template.render(
data=custom_data,
language=language,
config=self.config,
)
return html_output
except JINJA_GENERIC_EXCEPTION as e:
return self.handle_jinja_generic_exception(e)
except JINJA_DETAILED_EXCEPTION as e:
return self.handle_jinja_detailed_exception(e)
except Exception as e:
return self.handle_generic_exception(e)
def build(self):
"""
take entire source directory and build to static HTML files
"""
try:
shutil.rmtree(self.build_path)
except Exception as e:
pass
# check the config for languages and build away
config = self.get_config()
languages = config.get('languages', False)
if languages:
for language in languages:
language_build_path = os.path.join(self.build_path, language)
self.build_language(self.source_path, language_build_path,
language)
else:
self.build_language(self.source_path, self.build_path)
def build_language(self, source_path, build_path, language=False):
"""
copy a source path and build it into a build
"""
shutil.copytree(source_path, build_path)
try:
# re-write HTML as jinja2 HTML output
for path, folders, files in os.walk(build_path):
for file in files:
if file.endswith(
tuple(self.config.get('template_extensions'))):
self.save_static_file(path, file, language=language)
except Exception as e:
self.handle_generic_exception(e, 'Build error')
def save_static_file(self, path, file, **kwargs):
"""
save the static file to build directory
"""
try:
file_path = os.path.join(path, file)
language = kwargs.get('language', False)
html = self.render_html(file_path, build=True, language=language)
if html is None:
raise Exception(
'Failed to render HTML. Response from Prototype.render_html() is `None`.'
)
f = open(path + '/' + file, 'w')
f.write(html.encode('utf-8'))
f.close()
except Exception as e:
self.handle_generic_exception(e, 'Generate static file error')
def reload_hook(self):
print('Reload.')
def get_config(self):
return self.config
def handle_jinja_generic_exception(self, e):
exc_type, exc_obj, exc_tb = sys.exc_info()
error_renderer = ErrorRenderer()
response = error_renderer.format_html_traceback(e, exc_tb)
return response
def handle_jinja_detailed_exception(self, e):
exc_type, exc_obj, exc_tb = sys.exc_info()
error_renderer = ErrorRenderer()
response = error_renderer.format_html_traceback(e, exc_tb)
return response
def handle_generic_exception(self, e, msg='Generic Exception'):
exc_type, exc_obj, exc_tb = sys.exc_info()
error_renderer = ErrorRenderer()
response = error_renderer.format_html_traceback(e, exc_tb)
return response
from zine import environment
from zine.config import Configuration
from zine.api import db
from zine.config import ConfigurationTransactionError
from zine.models import User
from zine.utils.crypto import gen_pwhash, gen_secret_key, new_iid
from zine.utils.validators import is_valid_email, check
from zine.i18n import load_core_translations, has_language, list_languages
from werkzeug import Request, Response, redirect
from jinja2 import Environment, FileSystemLoader
template_path = path.join(path.dirname(__file__), 'templates')
jinja_env = Environment(loader=FileSystemLoader(template_path),
extensions=['jinja2.ext.i18n'])
jinja_env.install_null_translations()
#: header for the config file
CONFIG_HEADER = '''\
# Zine configuration file
# This file is also updated by the Zine admin interface.
# The charset of this file must be utf-8!
'''
def render_response(request, template_name, context):
context.update(
gettext=request.translations.gettext,
ngettext=request.translations.ngettext,
