class Statics(object):
"""Static css/js resources for Flask applications.
Relevant configuration settings from the Flask app config:
STATICS_MINIFY -- set to True to have minified resources selected instead of uncompressed resources.
Optional settings to enable specific static resources on all templates by default instead of on-demand:
STATICS_ENABLE_RESOURCE_<resource name> -- refer to resource_definitions.py for list of options. Set to True to
enable everywhere.
"""
def __init__(self, app=None):
self.all_variables = None
self.all_resources = None
self.blueprint = None
if app is not None:
self.init_app(app)
def init_app(self, app):
"""Initialize the extension."""
# Set default Flask config option.
app.config.setdefault('STATICS_MINIFY', False)
# Select resources.
self.all_resources = ALL_RESOURCES_MINIFIED if app.config.get(
'STATICS_MINIFY') else ALL_RESOURCES
self.all_variables = ALL_VARIABLES
# Add this instance to app.extensions.
if not hasattr(app, 'extensions'):
app.extensions = dict()
if 'statics' in app.extensions:
raise ValueError('Already registered extension STATICS.')
app.extensions['statics'] = _StaticsState(self, app)
# Initialize blueprint.
name = 'flask_statics_helper'
static_url_path = '{0}/{1}'.format(app.static_url_path, name)
self.blueprint = Blueprint(name,
__name__,
template_folder='templates',
static_folder='static',
static_url_path=static_url_path)
self.blueprint.add_app_template_global(
self.all_variables, '_flask_statics_helper_all_variables')
self.blueprint.add_app_template_global(
self.all_resources, '_flask_statics_helper_all_resources')
app.register_blueprint(self.blueprint)
class Statics(object):
"""Static css/js resources for Flask applications.
Relevant configuration settings from the Flask app config:
STATICS_MINIFY -- set to True to have minified resources selected instead of uncompressed resources.
Optional settings to enable specific static resources on all templates by default instead of on-demand:
STATICS_ENABLE_RESOURCE_<resource name> -- refer to resource_definitions.py for list of options. Set to True to
enable everywhere.
"""
def __init__(self, app=None):
self.all_variables = None
self.all_resources = None
self.blueprint = None
if app is not None:
self.init_app(app)
def init_app(self, app):
"""Initialize the extension."""
# Set default Flask config option.
app.config.setdefault('STATICS_MINIFY', False)
# Select resources.
self.all_resources = ALL_RESOURCES_MINIFIED if app.config.get('STATICS_MINIFY') else ALL_RESOURCES
self.all_variables = ALL_VARIABLES
# Add this instance to app.extensions.
if not hasattr(app, 'extensions'):
app.extensions = dict()
if 'statics' in app.extensions:
raise ValueError('Already registered extension STATICS.')
app.extensions['statics'] = _StaticsState(self, app)
# Initialize blueprint.
name = 'flask_statics_helper'
static_url_path = '{0}/{1}'.format(app.static_url_path, name)
self.blueprint = Blueprint(name, __name__, template_folder='templates', static_folder='static',
static_url_path=static_url_path)
self.blueprint.add_app_template_global(self.all_variables, '_flask_statics_helper_all_variables')
self.blueprint.add_app_template_global(self.all_resources, '_flask_statics_helper_all_resources')
app.register_blueprint(self.blueprint)
# -*- coding: utf-8 -*-
__author__ = 'wushuyi'
from flask import current_app, abort
from flask import Blueprint, render_template, redirect, url_for
from model import db
from model.blog import BlogPost, BlogClassify
import math
import view.blog as blog
blog_page = Blueprint('blog_page ', __name__, template_folder='templates')
blog_page.add_app_template_global(blog.get_public, name='blog_public')
blog_page.add_app_template_global(blog.get_classify_list,
name='blog_get_classify_list')
blog_page.add_url_rule('/favicon.ico', endpoint='page', view_func=blog.favicon)
blog_page.add_url_rule('/list/<int:page>',
endpoint='post_list',
view_func=blog.post_list)
blog_page.add_url_rule('/', endpoint='home', view_func=blog.post_list)
blog_page.add_url_rule('/tag/<string:query_classify>/<int:page>',
endpoint='tag_list',
view_func=blog.tag_list)
blog_page.add_url_rule('/tag/<string:query_classify>',
endpoint='tag',
view_func=blog.tag_list)
blog_page.add_url_rule('/article/<string:query_path>',
endpoint='posts',
view_func=blog.posts)
trips.add_url_rule('/new', view_func=CreateTripView.as_view('new'))
trips.add_url_rule('/<slug>/update',
view_func=UpdateTripView.as_view('update'))
# Points CRUD
def weekday_class(weekday: str) -> str:
weekday = escape(weekday)
wday_short = weekday[0:3]
weekday_classes = TwScheduleClasses.WEEKDAYS
return weekday_classes.get(wday_short, weekday_classes['_default'])
trips.add_app_template_filter(weekday_class, 'weekday_class')
trips.add_app_template_global(TwScheduleClasses.CELL_CLASS,
'schedule_cell_class')
trips.add_app_template_global(TwScheduleClasses.COMMON_WEEKDAY_CLASS,
'schedule_weekday_class')
def trip_point_wrapper(f):
@wraps(f)
def handler(slug: str, id: int):
trip = Trip.query.filter_by(slug=slug).first_or_404()
point = Point.query.filter(Point.trip == trip, Point.id == id)\
.first_or_404()
add_breadcrumb('Trips', url_for('.index'))
add_breadcrumb(trip.name, url_for('.show', slug=trip.slug))
return f(trip, point)
class Api(restful.Api):
'''
The main entry point for the application.
You need to initialize it with a Flask Application: ::
>>> app = Flask(__name__)
>>> api = Api(app)
Alternatively, you can use :meth:`init_app` to set the Flask application
after it has been constructed.
The endpoint parameter prefix all views and resources:
- The API root/documentation will be ``{endpoint}.root``
- A resource registered as 'resource' will be available as ``{endpoint}.resource``
:param app: the Flask application object
:type app: flask.Flask
:param version: The API version (used in Swagger documentation)
:type version: str
:param title: The API title (used in Swagger documentation)
:type title: str
:param description: The API description (used in Swagger documentation)
:type description: str
:param terms_url: The API terms page URL (used in Swagger documentation)
:type terms_url: str
:param contact: A contact email for the API (used in Swagger documentation)
:type contact: str
:param license: The license associated to the API (used in Swagger documentation)
:type license: str
:param license_url: The license page URL (used in Swagger documentation)
:type license_url: str
:param endpoint: The API base endpoint (default to 'api).
:type endpoint: str
:param default: The default namespace base name (default to 'default')
:type default: str
:param default_label: The default namespace label (used in Swagger documentation)
:type default_label: str
:param prefix: Prefix all routes with a value, eg v1 or 2010-04-01
:type prefix: str
:param default_mediatype: The default media type to return
:type default_mediatype: str
:param decorators: Decorators to attach to every resource
:type decorators: list
:param catch_all_404s: Use :meth:`handle_error`
to handle 404 errors throughout your app
:param url_part_order: A string that controls the order that the pieces
of the url are concatenated when the full url is constructed. 'b'
is the blueprint (or blueprint registration) prefix, 'a' is the api
prefix, and 'e' is the path component the endpoint is added with
:type catch_all_404s: bool
:param errors: A dictionary to define a custom response for each
exception or error raised during a request
:type errors: dict
:param authorizations: A Swagger Authorizations declaration as dictionary
:type authorizations: dict
'''
def __init__(self, app=None, version='1.0', title=None, description=None,
terms_url=None, contact=None, license=None, license_url=None,
endpoint='api', prefix=None, authorizations=None,
default='default', default_label='Default namespace', **kwargs):
self.version = version
self.title = title
self.description = description
self.terms_url = terms_url
self.contact = contact
self.license = license
self.license_url = license_url
self.endpoint = endpoint
self.authorizations = authorizations
self.models = {}
self.namespaces = []
self.default_namespace = ApiNamespace(self, '', default_label,
endpoint='{0}-declaration'.format(default),
json_path='/{0}.json'.format(default)
)
self.blueprint = Blueprint(self.endpoint, __name__,
template_folder='templates',
static_folder='static',
static_url_path='/swaggerui',
url_prefix=prefix,
)
@self.blueprint.route('/images/throbber.gif')
def fix_throbber():
return redirect(url_for('.static'.format(self.endpoint),
filename='bower/swagger-ui/dist/images/throbber.gif'
))
self.blueprint.record(self._deferred_blueprint_init)
super(Api, self).__init__(self.blueprint, **kwargs)
view_func = self.output(ApiSpecs.as_view(str('specs'), api=self))
url = self._complete_url('/specs.json', '')
self.blueprint.add_url_rule(url, view_func=view_func)
self.blueprint.add_url_rule('/', 'root', self.render_ui)
self.blueprint.add_app_template_global(self.swagger_static)
self.add_namespace(self.default_namespace)
if app:
app.register_blueprint(self.blueprint)
def init_app(self, app, **kwargs):
if isinstance(app, Blueprint):
return
self.title = kwargs.get('title', self.title)
self.description = kwargs.get('description', self.description)
self.terms_url = kwargs.get('terms_url', self.terms_url)
self.contact = kwargs.get('contact', self.contact)
self.license = kwargs.get('license', self.license)
self.license_url = kwargs.get('license_url', self.license_url)
app.register_blueprint(self.blueprint)
def render_ui(self):
'''Override this method to customize the documentation page'''
return render_template('swagger-ui.html', api_endpoint=self.endpoint, specs_url=self.specs_url)
def swagger_static(self, filename):
return url_for(
'{0}.static'.format(self.endpoint),
filename='bower/swagger-ui/dist/{0}'.format(filename)
)
def _register_namespace(self, ns):
'''Register a Swagger API declaration for a given API Namespace'''
endpoint = str(ns.endpoint)
view_func = self.output(ApiDeclaration.as_view(endpoint, api=self, namespace=ns))
url = self._complete_url(ns.json_path, '')
self.blueprint.add_url_rule(url, view_func=view_func)
def _register_view(self, app, resource, *urls, **kwargs):
super(Api, self)._register_view(app, resource, *urls, **kwargs)
# Ugly fix on owned endpoints
prefix = '{0}.'.format(self.blueprint.name)
self.endpoints = set(e if e.startswith(prefix) else ''.join((prefix, e)) for e in self.endpoints)
def add_resource(self, resource, *urls, **kwargs):
'''Register a Swagger API declaration for a given API Namespace'''
kwargs['endpoint'] = str(kwargs.pop('endpoint', None) or resource.__name__.lower())
if not kwargs.pop('namespace', None):
self.default_namespace.resources.append((resource, urls, kwargs))
# If blueprint is already registered, force URL declaration
if self.blueprint_setup:
kwargs['endpoint'] = str('{0}.{1}'.format(self.blueprint.name, kwargs['endpoint']))
self._register_view(self.blueprint_setup.app, resource, *urls, **kwargs)
else:
super(Api, self).add_resource(resource, *urls, **kwargs)
def add_namespace(self, ns):
if ns not in self.namespaces:
view_func = self.output(ApiDeclaration.as_view(ns.endpoint, api=self, namespace=ns))
url = self._complete_url(ns.json_path, '')
self.namespaces.append(ns)
self.endpoints.add(ns.endpoint)
if self.blueprint_setup:
# Set the rule to a string directly, as the blueprint is already set up.
self.blueprint_setup.add_url_rule(url, view_func=view_func)
else:
self.blueprint.add_url_rule(url, view_func=view_func)
def namespace(self, *args, **kwargs):
ns = ApiNamespace(self, *args, **kwargs)
self.add_namespace(ns)
return ns
def route(self, *urls, **kwargs):
def wrapper(cls):
doc = kwargs.pop('doc', None)
if doc:
self._handle_api_doc(cls, doc)
self.add_resource(cls, *urls, **kwargs)
return cls
return wrapper
def _handle_api_doc(self, cls, doc):
unshortcut_params_description(doc)
for key in 'get', 'post', 'put', 'delete':
if key in doc:
unshortcut_params_description(doc[key])
cls.__apidoc__ = merge(getattr(cls, '__apidoc__', {}), doc)
@property
def specs_url(self):
return url_for('{0}.specs'.format(self.endpoint), _external=True)
@property
def base_url(self):
return url_for('{0}.root'.format(self.endpoint), _external=True)
def doc(self, **kwargs):
'''Add some api documentation to the decorated object'''
def wrapper(documented):
self._handle_api_doc(documented, kwargs)
return documented
return wrapper
def owns_endpoint(self, endpoint):
'''Override the default implementation as there is always a Blueprint'''
return endpoint in self.endpoints
def abort(self, code=500, message=None, **kwargs):
'''Properly abort the current request'''
if message or kwargs and 'status' not in kwargs:
kwargs['status'] = code
if message:
kwargs['message'] = str(message)
restful.abort(code, **kwargs)
def model(self, name, model=None, fields=None, **kwargs):
'''
Register a model
Model can be either a dictionnary or a fields.Raw subclass.
'''
if isinstance(model, dict):
model = ApiModel(model)
model.__apidoc__['name'] = name
self.models[name] = model
return model
else:
def wrapper(cls):
cls.__apidoc__ = merge(getattr(cls, '__apidoc__', {}), kwargs)
cls.__apidoc__['name'] = name
if fields:
self.models[name] = fields
return cls
return wrapper
def parser(self):
'''Instanciate a RequestParser'''
return restful.reqparse.RequestParser()
def as_list(self, field):
'''Allow to specify nested lists for documentation'''
field.__apidoc__ = merge(getattr(field, '__apidoc__', {}), {'as_list': True})
return field
def marshal_with(self, fields, as_list=False):
'''
A decorator specifying the fields to use for serialization
:param as_list: Indicate that the return type is a list (for the documentation)
:type as_list: bool
'''
def wrapper(func):
doc = {'model': [fields]} if as_list else {'model': fields}
func.__apidoc__ = merge(getattr(func, '__apidoc__', {}), doc)
return restful.marshal_with(fields)(func)
return wrapper
def marshal_list_with(self, fields):
'''A shortcut decorator for ``marshal_with(as_list=True)``'''
return self.marshal_with(fields, True)
def marshal(self, data, fields):
'''A shortcut to the ``marshal`` helper'''
return restful.marshal(data, fields)
from pptx import Presentation
from pptxbuilder.constants import *
from pptxbuilder.excel_parser import parse, UnsupportedFileException, IncompatibleExcelException
from pptxbuilder.helper import str_chart_type, str_series_opt
from pptxbuilder.pptx_helper import (
add_bar_chart,
add_column_chart,
add_line_chart,
add_doughnut_chart,
PPT_CUSTOM_LABEL_SEPERATOR)
from pptxbuilder.util import random_alphanum
builder_bp = Blueprint('builder', __name__)
builder_bp.add_app_template_global(SERIES_BY_CATEGORIES, name='SERIES_BY_CATEGORIES')
builder_bp.add_app_template_global(SERIES_BY_OPTIONS, name='SERIES_BY_OPTIONS')
builder_bp.add_app_template_global(str_series_opt)
builder_bp.add_app_template_global(CHART_TYPE_BAR, name='CHART_TYPE_BAR')
builder_bp.add_app_template_global(CHART_TYPE_COLUMN, name='CHART_TYPE_COLUMN')
builder_bp.add_app_template_global(CHART_TYPE_LINE, name='CHART_TYPE_LINE')
builder_bp.add_app_template_global(CHART_TYPE_PIE, name='CHART_TYPE_PIE')
builder_bp.add_app_template_global(str_chart_type)
this_dir = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
class Create(MethodView):
def post(self):
xls_str = request.form.get('file')
prozorro_api_item_path,
prozorro_api_complaint_path,
prozorro_portal_tender_path,
prozorro_api_url,
prozorro_portal_url,
url_for_search,
)
bp = Blueprint("app_views", __name__, template_folder="templates")
bp.add_app_template_filter(typing_is_dict, "typing_is_dict")
bp.add_app_template_filter(typing_is_list, "typing_is_list")
bp.add_app_template_filter(prozorro_portal_url, "prozorro_portal_url")
bp.add_app_template_filter(prozorro_portal_tender_path,
"prozorro_portal_tender_path")
bp.add_app_template_filter(prozorro_api_url, "prozorro_api_url")
bp.add_app_template_filter(prozorro_api_tender_path,
"prozorro_api_tender_path")
bp.add_app_template_filter(prozorro_api_item_path, "prozorro_api_item_path")
bp.add_app_template_filter(prozorro_api_complaint_path,
"prozorro_api_complaint_path")
bp.add_app_template_global(url_for_search, "url_for_search")
@bp.route("/", methods=["GET"])
@login_groups_required(["admins", "accountants"])
def index():
return render_template("index.html")
class ModelViewer(object):
"""Blueprint for inspecting saved model definitions
Args:
app: The bgexplorer Flask object
modeldb: a ModelDB object. If None, will get from the Flask object
url_prefix (str): Where to mount this blueprint relative to root
"""
defaultversion = 'HEAD'
joinkey = '___'
def __init__(self,
app=None,
modeldb=None,
cacher=InMemoryCacher(),
url_prefix='/explore'):
self.app = app
self._modeldb = modeldb
self.bp = Blueprint('modelviewer',
__name__,
static_folder='static',
template_folder='templates',
url_prefix='/<modelname>/<version>')
self.bp.add_app_template_global(lambda: self, 'getmodelviewer')
self.set_url_processing()
self.register_endpoints()
if self.app:
self.init_app(app, url_prefix)
self._threads = {}
self._cacher = cacher
#### User Overrides ####
self.bomcols = bomfuncs.getdefaultcols()
def init_app(self, app, url_prefix=''):
"""Register ourselves with the app"""
app.register_blueprint(self.bp,
url_prefix=url_prefix + self.bp.url_prefix)
app.extensions['ModelViewer'] = self
@property
def modeldb(self):
return self._modeldb or utils.get_modeldb()
@property
def simsdb(self):
return g.simsdbview.simsdb
def set_url_processing(self):
"""process model objects into URL strings, and pre-load models
into the `flask.g` object before passing to endpoint functions
"""
@self.bp.after_request
def addpostheaders(response):
""" Add cache-control headers to all modelviewer responses """
if self.app.config.get('NO_CLIENT_CACHE'):
return
# todo: add Last-Modified
response.headers["Cache-Control"] = "private, max-age=100"
try:
response.headers['ETag'] = make_etag(g.model)
except (AttributeError, KeyError): # model is not loaded in g
pass
return response
@self.bp.url_defaults
def add_model(endpoint, values):
model = values.pop('model', None) or g.get('model', None)
if model:
#model could be object or dict
name = getattr(model, 'name', None) or model.get('name', None)
version = getattr(model, 'version', None)
if version is None and hasattr(model, 'get'):
version = model.get('version', None)
values.setdefault('modelname', name)
permalink = values.pop('permalink', None)
if permalink is not None:
values['version'] = (version
if permalink else self.defaultversion)
else:
values.setdefault(
'version', version
if not g.get('permalink') else self.defaultversion)
elif 'modelid' in values:
values['modelname'] = values.pop('modelid')
values['version'] = '_'
values['permalink'] = 1
#transform components, specs into IDs
if 'component' in values:
values['componentid'] = values.pop('component').id
if 'spec' in values:
values['specid'] = values.pop('spec').getrootspec().id
if 'match' in values:
values['matchid'] = values.pop('match').id
@self.bp.url_value_preprocessor
def find_model(endpoint, values):
# URL has different formats that result in different queries
query = None
if 'modelid' in values:
query = values.pop('modelid')
elif 'modelname' in values:
query = {'name': values.pop('modelname')}
version = values.pop('version', self.defaultversion)
if version == '_': #special, means name is actually ID
query['_id'] = query.pop('name')
elif version != self.defaultversion:
query['version'] = version
if not query:
abort(400, "Incomplete model specification")
# this function is called before `before_requests`, but we don't
# want to extract the model if the client requested a cached
# view. So we have to do the cache checking here
etagreq = request.headers.get('If-None-Match')
if etagreq and not self.app.config.get('NO_CLIENT_CACHE'):
# construct the etag from the DB entry
projection = {'editDetails.date': True}
modeldict = self.modeldb.get_raw_model(query, projection)
etag = make_etag(modeldict)
if etagreq == etag:
abort(make_response('', '304 Not Modified',
{'ETag': etag}))
# if we get here, it's not in client cache
g.model = utils.getmodelordie(query, self.modeldb)
if version == self.defaultversion:
g.permalink = url_for(endpoint, permalink=True, **values)
g.simsdbview = utils.get_simsdbview(model=g.model)
#construct the cached datatable in the background
if self._cacher:
self.build_datatable(g.model)
def register_endpoints(self):
"""Define the view functions here"""
@self.bp.route('/')
def overview():
history = self.modeldb.get_model_history(g.model.id)
return render_template('overview.html', history=history)
@self.bp.route('/component/')
@self.bp.route('/component/<componentid>') #should be uuid type?
def componentview(componentid=None):
if componentid:
component = utils.getcomponentordie(g.model, componentid)
matches = g.model.getsimdata(component=component)
datasets = sum((m.dataset or [] for m in matches), [])
return render_template("componentview.html",
component=component,
datasets=datasets)
else:
return render_template("componentsoverview.html")
@self.bp.route('/emissions/')
def emissionsoverview():
rootspecs = [s for s in g.model.specs.values() if not s.parent]
return render_template("emissionsoverview.html",
rootspecs=rootspecs)
@self.bp.route('/emission/<specid>')
def emissionview(specid):
spec = utils.getspecordie(g.model, specid)
#find all simulation datasets associated to this spec
matches = []
if spec.getrootspec() == spec:
matches = g.model.getsimdata(rootspec=spec)
else:
matches = g.model.getsimdata(spec=spec)
datasets = sum((m.dataset or [] for m in matches), [])
return render_template('emissionview.html',
spec=spec,
matches=matches,
datasets=datasets)
@self.bp.route('/simulations/')
def simulationsoverview():
return render_template("simulationsoverview.html")
@self.bp.route('/queries/')
def queriesoverview():
#build a unique list of all queries
queries = {}
for m in g.model.getsimdata():
key = str(m.query)
if key not in queries:
queries[key] = []
queries[key].append(m)
return render_template('queriesoverview.html', queries=queries)
@self.bp.route('/dataset/<dataset>')
def datasetview(dataset):
detail = self.simsdb.getdatasetdetails(dataset)
return render_template("datasetview.html",
dataset=dataset,
detail=detail)
@self.bp.route('/simdatamatch/<matchid>')
def simdatamatchview(matchid):
match = utils.getsimdatamatchordie(g.model, matchid)
linkspec = match.spec.getrootspec()
return render_template("simdatamatchview.html", match=match)
@self.bp.route('/billofmaterials')
def billofmaterials():
bomrows = bomfuncs.getbomrows()
return render_template("billofmaterials.html",
bomrows=bomrows,
bomcols=self.bomcols)
@self.bp.route('/datatable')
def datatable():
"""Return groups and values for all simdatamatches"""
return self.get_datatable(g.model)
@self.bp.route('/tables/default')
def tablesdefault():
"""Show some default tables with the calculated rows"""
return render_template("tablesdefault.html")
@self.bp.route('/charts/default')
def chartsdefault():
"""Show some default charts with the calculated rates"""
return render_template("chartsdefault.html")
@self.bp.route('/spectra/default')
def spectradefault():
return render_template("spectradefault.html")
@self.bp.route('/export')
def export():
"""Present the model as a JSON document"""
d = g.model.todict()
#replace ObjectIds with strings
if isinstance(d.get('_id'), ObjectId):
d['_id'] = str(d['_id'])
if isinstance(d.get('derivedFrom'), ObjectId):
d['derivedFrom'] = str(d['derivedFrom'])
return Response(json.dumps(d), mimetype="application/json")
@self.bp.route('/getspectrum')
@self.bp.route('/getspectrum/<specname>')
def getspectrum(specname=None):
# get the generator for the spectrum
if not specname:
valname = request.args.get('val')
if not valname:
abort(404,
"Either spectrum name or value name is required")
specname = g.simsdbview.values_spectra.get(valname)
if not specname:
# valname might have a unit suffix applied to it
index = valname.rfind(' [')
valname = valname[:index]
specname = g.simsdbview.values_spectra.get(valname)
if not specname:
abort(404, f"No spectrum associated to value '{valname}'")
speceval = g.simsdbview.spectra.get(specname)
if speceval is None:
abort(404, f"No spectrum generator for '{specname}'")
log.debug(f"Generating spectrum: {specname}")
title = specname
# get the matches
matches = request.args.getlist('m')
try:
matches = [g.model.simdata[m] for m in matches]
except KeyError:
abort(404, "Request for unknown sim data match")
if not matches:
# matches may be filtered by component or spec
component = None
if 'componentid' in request.args:
component = utils.getcomponentordie(
g.model, request.args['componentid'])
title += ", Component = " + component.name
rootspec = None
if 'specid' in request.args:
rootspec = utils.getspecordie(g.model,
request.args['specid'])
title += ", Source = " + rootspec.name
matches = g.model.getsimdata(rootcomponent=component,
rootspec=rootspec)
# test for a group filter
groupname = request.args.get('groupname')
groupval = request.args.get('groupval')
if groupname and groupval and groupval != g.simsdbview.groupjoinkey:
try:
groupfunc = g.simsdbview.groups[groupname]
except KeyError:
abort(404, f"No registered grouping function {groupname}")
def _filter_group(match):
mgval = g.simsdbview.evalgroup(match, groupname, False)
return g.simsdbview.is_subgroup(mgval, groupval)
matches = list(filter(_filter_group, matches))
title += ", " + groupname + " = "
title += '/'.join(g.simsdbview.unflatten_gval(groupval, True))
if not matches:
abort(404, "No sim data matching query")
spectrum = self.simsdb.evaluate([speceval], matches)[0]
if not hasattr(spectrum, 'hist') or not hasattr(
spectrum, 'bin_edges'):
abort(500, f"Error generating spectrum, got {type(spectrum)}")
unit = g.simsdbview.spectra_units.get(specname, None)
if unit is not None:
try:
spectrum.hist.ito(unit)
except AttributeError: #not a quantity
pass
fmt = request.args.get("format", "png").lower()
response = None
if fmt == 'tsv':
response = Response(self.streamspectrum(spectrum, sep='\t'),
mimetype='text/tab-separated-value')
elif fmt == 'csv':
response = Response(self.streamspectrum(spectrum, sep=','),
mimetype='text/csv')
elif fmt == 'png':
response = self.specimage(spectrum, title=title)
else:
abort(400, f"Unhandled format specifier {fmt}")
return response
def streamspectrum(self,
spectrum,
sep=',',
include_errs=True,
fmt='{:.5g}'):
""" Return a generator response for a spectrum
Args:
spectrum (Histogram): spectrum to stream
sep (str): separator (e.g. csv or tsv)
include_errs (bool): if True, include a column for errors
fmt (str): format specifier
Returns:
generator to construct Response
"""
bins, vals = spectrum.bin_edges, spectrum.hist
vals_has_units = hasattr(vals, 'units')
bins_has_units = hasattr(bins, 'units')
# yield the header
head = ["Bin", "Value"]
if bins_has_units:
head[0] += f' [{bins.units}]'
if vals_has_units:
head[1] += f' [{vals.units}]'
if include_errs:
head.append('Error')
yield sep.join(head) + '\n'
# now remove units and extract errors
if vals_has_units:
vals = vals.m
if bins_has_units:
bins = bins.m
vals, errs = unumpy.nominal_values(vals), unumpy.std_devs(vals)
for abin, aval, anerr in zip(bins, vals, errs):
yield sep.join(
(str(abin), fmt.format(aval), fmt.format(anerr))) + '\n'
def specimage(self, spectrum, title=None, logx=True, logy=True):
""" Generate a png image of a spectrum
Args:
spectrum (Histogram): spectrum to plot
title (str): title
logx (bool): set x axis to log scale
logy (bool): set y axis to log scale
Returns:
a Response object
"""
if Figure is None:
abort(500, "Matplotlib is not available")
log.debug("Generating spectrum image")
# apparently this aborts sometimes?
try:
x = spectrum.bin_edges.m
except AttributeError:
x = spectrum.bin_edges
fig = Figure()
ax = fig.subplots()
ax.errorbar(
x=x[:-1],
y=unumpy.nominal_values(spectrum.hist),
yerr=unumpy.std_devs(spectrum.hist),
drawstyle='steps-post',
elinewidth=0.6,
)
ax.set_title(title)
if logx:
ax.set_xscale('log')
if logy:
ax.set_yscale('log')
if hasattr(spectrum.bin_edges, 'units'):
ax.set_xlabel(f'Bin [{spectrum.bin_edges.units}]')
if hasattr(spectrum.hist, 'units'):
ax.set_ylabel(f"Value [{spectrum.hist.units}]")
"""
#limit to at most N decades...
maxrange = 100000
ymin, ymax = plt.ylim()
ymax = 10**ceil(log10(ymax))
ymin = max(ymin, ymax/maxrange)
plt.ylim(ymin, ymax)
plt.tick_params(which='major',length=6, width=1)
plt.tick_params(which='minor',length=4,width=1)
iplt.gcf().set_size_inches(9,6)
plt.gca().set_position((0.08,0.1,0.7,0.8))
"""
log.debug("Rendering...")
out = BytesIO()
fig.savefig(out, format='png')
log.debug("Done generating image")
size = out.tell()
out.seek(0)
res = Response(
out.getvalue(),
content_type='image/png',
headers={
'Content-Length': size,
'Content-Disposition': 'inline',
},
)
return res
#need to pass simsdb because it goes out of context
def streamdatatable(self, model, simsdbview=None):
"""Stream exported data table so it doesn't all go into mem at once
"""
log.debug(f"Generating data table for model {model.id}")
#can't evaluate values if we don't have a simsdb
if simsdbview is None:
simsdbview = utils.get_simsdbview(model=model) or SimsDbView()
simsdb = simsdbview.simsdb
valitems = list(simsdbview.values.values())
matches = model.simdata.values()
#send the header
valheads = [
'V_' + v + (' [%s]' % simsdbview.values_units[v]
if v in simsdbview.values_units else '')
for v in simsdbview.values
]
yield ('\t'.join(
chain(['ID'],
('G_' + g for g in simsdbview.groups), valheads)) + '\n')
#loop through matches
for match in matches:
evals = []
if valitems:
evals = simsdb.evaluate(valitems, match)
for index, vlabel in enumerate(simsdbview.values):
# convert to unit if provided
unit = simsdbview.values_units.get(vlabel, None)
if unit:
try:
evals[index] = evals[index].to(unit).m
except AttributeError: #not a Quantity...
pass
except units.errors.DimensionalityError as e:
if evals[index] != 0:
log.warning(e)
evals[index] = getattr(evals[index], 'm', 0)
# convert to string
evals[index] = "{:.3g}".format(evals[index])
if match.spec.islimit:
evals[index] = '<' + evals[index]
groupvals = (g(match) for g in simsdbview.groups.values())
groupvals = (simsdbview.groupjoinkey.join(g) if isinstance(
g, (list, tuple)) else g for g in groupvals)
yield (
'\t'.join(chain([match.id],
(str(g) for g in groupvals), evals)) + '\n')
#sleep(0.2) # needed to release the GIL
log.debug(f"Finished generating data table for model {model.id}")
@staticmethod
def datatablekey(model):
return "datatable:" + make_etag(model)
def build_datatable(self, model):
"""Generate a gzipped datatable and cache it
Args:
model: a BgModel
Returns:
None if no cacher is defined
0 if the result is already cached
Thread created to generate the cache otherwise
"""
#don't bother to call if we don't have a cache
if not self._cacher:
return None
#TODO: self._threads and self._Cacher should probably be mutexed
#see if there's already a worker
key = self.datatablekey(model)
if key in self._threads:
return self._threads[key]
#see if it's already cached
if self._cacher.test(key):
return 0
#if we get here, we need to generate it
def cachedatatable(dbview):
compressor = zlib.compressobj()
res = b''.join(
compressor.compress(s.encode('utf-8'))
for s in self.streamdatatable(model, dbview))
res += compressor.flush()
self._cacher.store(key, res)
self._threads.pop(key) #is this a bad idea???
dbview = utils.get_simsdbview(model=model)
thread = threading.Thread(target=cachedatatable,
name=key,
args=(dbview, ))
self._threads[key] = thread
thread.start()
return thread
def get_datatable(self, model):
"""Return a Result object with the encoded or streamed datatable"""
key = self.datatablekey(model)
if not self._cacher: # or self.modeldb.is_model_temp(model.id):
#no cache, so stream it directly, don't bother to zip it
#should really be text/csv, but then browsersr won't let you see it
return Response(self.streamdatatable(model), mimetype='text/plain')
if not self._cacher.test(key):
thread = self.build_datatable(model)
if thread:
thread.join() #wait until it's done
res = self._cacher.get(key)
if not res:
abort(500, "Unable to generate datatable")
return Response(res,
headers={
'Content-Type': 'text/plain;charset=utf-8',
'Content-Encoding': 'deflate',
})
def get_componentsort(self, component, includeself=True):
"""Return an array component names in assembly order to be passed
to the javascript analyzer for sorting component names
"""
#TODO: cache this
result = [component.name] if includeself else []
for child in component.getcomponents(merge=False):
branches = self.get_componentsort(child)
if includeself:
branches = [
self.joinkey.join((component.name, s)) for s in branches
]
result.extend(branches)
return result
def get_groupsort(self):
res = dict(**g.simsdbview.groupsort)
#todo: set up provided lists
if 'Component' not in res:
res['Component'] = self.get_componentsort(g.model.assemblyroot,
False)
return res
def eval_matches(self, matches, dovals=True, dospectra=False):
""" Evaluate `matches` for all registered values and specs
Args:
matches: list of SimDataMatch objects to evaluate
dovals (bool): include entries from `self.values` ?
dospectra (bool): include entries from `self.spectra` ?
Returns:
values (dict): dictionary mapping of keys in `self.values` and
`self.spectra` to evaluated results. If a key in
`spectra` conflicts with one in values, it will be
renamed to "spectrum_<key>"
"""
# this no longer works, but wasn't used. Keep around for now...
raise NotImplementedError()
vals = dict(**self.values) if dovals else {}
if dospectra:
for key, spectrum in self.spectra.items():
if key in vals:
key = f'spectrum_{key}'
vals[key] = spectrum
result = dict(
zip(vals.keys(), self.simsdb.evaluate(vals.values(), matches)))
if dovals:
for key, unit in self.values_units.items():
try:
result[key].ito(unit)
except AttributeError:
pass
if dospectra:
for key, unit in self.spectra_units.items():
if dovals and key in self.values:
key = f'spectrum_{key}'
try:
result[key].ito(unit)
except AttributeError:
pass
return result
if posts:
#post_counts = len([post for post in posts if post.draft==False])
global_data['postCounts'] = posts
shuos = Shuoshuo.query.order_by(Shuoshuo.timestamp.desc()).all()
if shuos:
global_data['newShuo'] = shuos[0].body_to_html
guestbook = Page.query.filter_by(url_name='guestbook').first()
if guestbook:
guestbook_counts = guestbook.comments.count()
global_data['guestbookCounts'] = guestbook_counts
all_boxes = SideBox.query.order_by(SideBox.id.desc()).all()
if all_boxes:
adv_boxes = [
box for box in all_boxes
if box.unable is False and box.is_advertising is True
]
global_data['ads_boxes'] = adv_boxes
my_boxes = [
box for box in all_boxes
if box.unable is False and box.is_advertising is False
]
global_data['my_boxes'] = my_boxes
return global_data
main.add_app_template_global(global_datas, 'global_datas')
# Author: jianglin # Email: [email protected] # Created: 2017-03-17 13:49:48 (CST) # Last Update:星期日 2017-8-27 22:58:3 (CST) # By: # Description: # ************************************************************************** from flask import Blueprint from .views import (BlogListView, BlogView, RssView, ArchiveView) from .filters import (safe_markdown, random_fortune, tag_archives, category_archives, time_archives, orgmode) site = Blueprint('blog', __name__) bloglist_view = BlogListView.as_view('bloglist') site.add_url_rule('', view_func=bloglist_view) site.add_url_rule('/', view_func=bloglist_view) site.add_url_rule('/<int:blogId>', view_func=BlogView.as_view('blog')) site.add_url_rule('/archives', view_func=ArchiveView.as_view('archive')) site.add_url_rule('/rss', view_func=RssView.as_view('rss')) site.add_app_template_global(random_fortune) site.add_app_template_global(tag_archives) site.add_app_template_global(category_archives) site.add_app_template_global(time_archives) site.add_app_template_filter(safe_markdown) site.add_app_template_filter(orgmode) def init_app(app): app.register_blueprint(site, url_prefix='/blog')
from .forms import DataJointFormFactory
PER_PAGE = 20
ENABLE_EDIT=True
djpage = Blueprint('djpage', __name__,
template_folder='templates',
static_folder='static',
static_url_path='/%s' % __name__
)
form_factory = DataJointFormFactory()
_registered_relations = {}
from .display_tools import display
from .edit import enter
def register(for_form=False, **kwargs):
for name, rel in kwargs.items():
assert isinstance(rel, dj.BaseRelation), "rel must be a subclass of dj.Relation"
_registered_relations[name] = rel
if for_form:
form_factory.register(**kwargs)
djpage.add_app_template_global(ENABLE_EDIT, 'edit_enabled')
rule = '/viewattrs/' + name + "/"
route = dict(endpoint=name, view_func=viewattrs(name, obj))
attrsview.add_url_rule(rule + '<path:keypath>', **route)
attrsview.add_url_rule(rule, **route)
@contextfunction
def pancontext(context, keypath=""):
obj = dict(context.items())
view_func = viewattrs('context', obj)
return view_func(keypath)
attrsview = Blueprint('attrsview', __name__)
attrsview_routes('current_app', current_app)
attrsview.add_app_template_global(pancontext)
@attrsview.route('/viewattrs/context/')
@attrsview.route('/viewattrs/context/<path:keypath>')
def viewcontext(keypath=""):
context = 'pancontext(keypath="{}")|safe'.format(keypath)
return render_template_string('{{ ' + context + '}}')
def create_attrsview_app():
"""app factory"""
from basics import basics
from templateview import templateview
app = Flask(__name__)
app.config['TEMPLATES_AUTO_RELOAD'] = True
# -*- coding: utf-8 -*-
__author__ = 'wushuyi'
from flask import current_app, abort
from flask import Blueprint, render_template, redirect, url_for
from model import db
from model.blog import BlogPost, BlogClassify
import math
import view.blog as blog
blog_page = Blueprint(
'blog_page ',
__name__,
template_folder='templates'
)
blog_page.add_app_template_global(blog.get_public, name='blog_public')
blog_page.add_app_template_global(blog.get_classify_list, name='blog_get_classify_list')
blog_page.add_url_rule('/favicon.ico', endpoint='page', view_func=blog.favicon)
blog_page.add_url_rule('/list/<int:page>', endpoint='post_list', view_func=blog.post_list)
blog_page.add_url_rule('/', endpoint='home', view_func=blog.post_list)
blog_page.add_url_rule('/tag/<string:query_classify>/<int:page>', endpoint='tag_list', view_func=blog.tag_list)
blog_page.add_url_rule('/tag/<string:query_classify>', endpoint='tag', view_func=blog.tag_list)
blog_page.add_url_rule('/article/<string:query_path>', endpoint='posts', view_func=blog.posts)
blog_page.add_url_rule('/search', endpoint='search', view_func=blog.search)
blog_page.add_url_rule('/search/<int:page>', endpoint='search_list', view_func=blog.search)
def link_to_file(filepath, filename):
if os.path.isfile(os.path.join(filepath, filename)):
item = db.File.objects(filepath=filepath, filename=filename).first()
if item is not None:
linkURL = url_for('mongomanager.showfile', id=str(item.id))
link = '<a href="' + linkURL + '">' + str(item.filename) + '</a>'
else:
link = str(filename) + ' [Not indexed]'
else:
linkURL = url_for('mongomanager.render_directory',
path=os.path.join(filepath, filename))
link = "<a href='" + linkURL + "'>" + str(filename) + "</a>"
return link
mongomanager.add_app_template_global(link_to_file)
# Construct a link to the parent directory
@requires_perm('admin')
def link_to_parent_dir(path):
parentpath = os.path.abspath(os.path.join(path, '..'))
link = ("<a href='" +
url_for('mongomanager.render_directory', path=parentpath) +
"'>../</a>")
return link
mongomanager.add_app_template_global(link_to_parent_dir)
from flask import Blueprint, render_template, redirect, url_for, flash
from model.NewPost import NewPost
from model.NewThread import NewThread
from model.Post import Post, render_for_threads
from model.PostRemoval import PostRemoval
from model.PostReplyPattern import url_for_post
from model.Poster import Poster
from model.Slip import get_slip
from model.SubmissionError import SubmissionError
from model.Thread import Thread
from model.ThreadPosts import ThreadPosts
from shared import db
threads_blueprint = Blueprint('threads', __name__, template_folder='template')
threads_blueprint.add_app_template_global(url_for_post)
@threads_blueprint.route("/new/<int:board_id>")
def new(board_id):
return render_template("new-thread.html", board_id=board_id)
@threads_blueprint.route("/new", methods=["POST"])
def submit():
try:
thread = NewThread().post_impl()
return redirect(url_for("threads.view", thread_id=thread.id))
except SubmissionError as e:
flash(str(e.args[0]))
return redirect(url_for("threads.new", board_id=e.args[1]))
SearchDeleteForm
from .importing import start_import_thread, threads
from .search import Searcher
from .widgets import \
EditBatchItemFormWidget, \
FormRenderer, \
FormWidget, \
LibraryRenderer, \
SearchFormWidget, \
SavedSearchFormWidget, WidgetRenderer
from . import csrf
libraries = Blueprint('libraries', __name__)
libraries.add_app_template_global(lambda: str(uuid.uuid1()), name='uuid')
libraries.add_app_template_global(User.current_uid, name='user_current_uid')
libraries.add_app_template_global(Folder.from_path, name='folder_from_path')
libraries.add_app_template_global(Library.enumerate_all,
name='library_enumerate_all')
libraries.add_app_template_global(Tag.enumerate_roots,
name='tag_enumerate_roots')
libraries.add_app_template_global(SavedSearch.enumerate_user,
name='saved_search_enumerate_user')
def url_self(**args):
return url_for(request.endpoint, **dict(request.view_args, **args))
current_app.jinja_env.globals.update(url_self=url_self)
from flask import Blueprint, request, render_template, redirect, url_for, session, flash
from werkzeug.security import check_password_hash
from model.Session import Session
from model.Slip import Slip, gen_slip, make_session, get_slip, slip_from_id
from shared import db
slip_blueprint = Blueprint('slip', __name__, template_folder='template')
slip_blueprint.add_app_template_global(get_slip)
slip_blueprint.add_app_template_global(slip_from_id)
@slip_blueprint.route("/")
def landing():
return render_template("slip.html")
@slip_blueprint.route("/register", methods=["POST"])
def register():
name = request.form["name"]
password = request.form["password"]
slip = gen_slip(name, password)
db.session.flush()
make_session(slip)
db.session.commit()
return redirect(url_for("slip.landing"))
@slip_blueprint.route("/login", methods=["POST"])
def login():
from model.Board import Board
from model.BoardList import BoardList
from model.BoardListCatalog import BoardCatalog
from model.Post import render_for_catalog
from model.Slip import get_slip
from model.Tag import Tag
from shared import db
def style_for_tag(tag_name):
tag = db.session.query(Tag).filter(Tag.name == tag_name).one()
return {"bg_style": tag.bg_style, "text_style": tag.text_style}
boards_blueprint = Blueprint('boards', __name__, template_folder='template')
boards_blueprint.add_app_template_global(style_for_tag)
@boards_blueprint.route("/")
def list():
return render_template("board-index.html", boards=BoardList().get())
@boards_blueprint.route("/<int:board_id>")
def catalog(board_id):
threads = BoardCatalog().retrieve(board_id)
board_name = db.session.query(Board).filter(Board.id == board_id).one().name
render_for_catalog(threads)
return render_template("catalog.html", threads=threads, board_id=board_id, board_name=board_name)
class SimsViewer(object):
"""Blueprint for searching and inspecting simulation data
Args:
app: the bgexplorer Flask object
url_prefix (str): Where to mount this blueprint relative to root
detailtemplate: path to template file for detailed simulation view
enableupload (bool): if True, allow uploading new entries
uploadsummary (func): generate a summary projection from uploaded
(json-generated) documents
"""
def __init__(self,
app=None,
url_prefix='/simulations',
detailtemplate=None,
enableupload=True,
uploadsummary=None):
self.app = app
self.enable_upload = enableupload
self.uploadsummary = uploadsummary
self.bp = Blueprint('simsviewer',
__name__,
static_folder='static',
template_folder='templates')
self.bp.add_app_template_global(lambda: self, 'getsimsviewer')
self.bp.add_app_template_global(findsimmatches, 'findsimmatches')
self.bp.add_app_template_global(json.dumps, 'json_dumps')
#handle 'query' requests for non strings
@self.bp.url_defaults
def url_defaults(endpoint, values):
query = values.get('query', None)
if query and not isinstance(query, str):
values['query'] = json.dumps(query)
@self.bp.before_request
def preprocess():
if 'query' in request.args:
try:
args = request.args.copy()
args['query'] = json.loads(args['query'])
request.args = args
except (KeyError, json._json.JSONDecodeError):
pass
self.register_endpoints()
if self.app:
self.init_app(app, url_prefix)
def init_app(self, app, url_prefix=''):
"""Register ourselves with the app"""
app.register_blueprint(self.bp, url_prefix=url_prefix)
app.extensions['SimulationsViewer'] = self
key = "ENABLE_SIMULATION_UPLOADS"
self.enable_upload = app.config.setdefault(key, self.enable_upload)
@property
def simsdb(self):
return g.simsdbview.simsdb
def getcolnames(self, sims):
""" Get the column names to display in summary table """
columns = []
try:
columns = g.simsdbview.summarycolumns
except AttributeError:
pass
if sims and not columns:
#non-underscore keys with string or number values
for key, val in sims[0].items():
if (not key.startswith('_') and key != 'id'
and isinstance(val, (str, int, float))):
columns.append(key)
return columns
def register_endpoints(self):
"""Attach the model if requested"""
@self.bp.url_value_preprocessor
def find_model(endpoint, values):
if 'modelid' in request.args:
g.model = utils.getmodelordie(request.args['modelid'])
values.setdefault('dbname', g.model.simsdb)
if 'dbname' in values:
g.dbname = values.pop('dbname')
g.simsdbview = utils.get_simsdbview(name=g.dbname)
""" make sure we have a simsdb """
@self.bp.url_defaults
def addsimsdbview(endpoint, values):
model = values.pop('model', None) or g.get('model', None)
if model:
#values['modelid'] = model.id
dbname = model.simsdb
if not dbname:
dbname = current_app.getdefaultsimviewname()
values.setdefault('dbname', dbname)
simsdbview = values.pop('simsdbview', None) or g.get(
'simsdbview', None)
if simsdbview and 'dbname' not in values:
values['dbname'] = current_app.getsimviewname(simsdbview)
"""Define the view functions here"""
@self.bp.route('/')
def index():
dbnames = list(current_app.simviews.keys())
if len(dbnames) == 1:
return redirect(url_for('.overview', dbname=dbnames[0]))
return render_template('listdbs.html', dbnames=dbnames)
@self.bp.route('/<dbname>/')
def overview():
query = request.args.get('query', None)
try:
projection = g.simsdbview.summarypro
sims = list(self.simsdb.runquery(query, projection=projection))
except Exception as e:
abort(400, "Invalid query specifier")
columns = self.getcolnames(sims)
return render_template('simoverview.html',
sims=sims,
query=query,
colnames=columns)
@self.bp.route('/<dbname>/dataset/<dataset>')
def detailview(dataset):
detail = self.simsdb.getdatasetdetails(dataset)
matches = findsimmatches(dataset)
return render_template('datasetview.html',
dataset=dataset,
detail=detail)
@self.bp.route('/<dbname>/dataset/<dataset>/raw')
def rawview(dataset):
"""Export the dataset as raw JSON"""
detail = self.simsdb.getdatasetdetails(dataset)
return json.jsonify(detail)
if not self.enable_upload:
return
@self.bp.route('/<dbname>/api/upload', methods=('POST', ))
def api_upload():
""" Upload files to be inserted, return JSON response """
files = request.files.getlist('fupload')
if request.is_json:
print(request.data, request.json)
fakefile = io.BytesIO(request.data)
fakefile.filename = 'JSON'
files = [fakefile]
try:
result = g.simsdbview.handle_uploads(files)
except NotImplementedError:
abort(501, "Uploads are not implemented for this database")
except BaseException as e:
err = f"{type(e).__name__}: {str(e)}"
result = dict(entries={}, errors={None: err})
return result
@self.bp.route('/<dbname>/upload', methods=('GET', 'POST'))
def upload():
""" Upload new JSON-formatted entries """
result = None
if request.method == 'POST':
result = api_upload()
return render_template('uploadsimdata.html', result=result)
"""
flask_app.register_blueprint(admin, url_prefix="/admin/")
login_manager.init_app(flask_app)
@login_manager.unauthorized_handler
def unauthorized_request() -> Response:
"""This function is called if a unauthorized user requests a route which is
protected.
"""
logger.warning('User tried to access restricted page without password',
requested_url=request.url)
return redirect(url_for('.login', next_url=request.url))
admin.add_app_template_global(lambda: current_user, 'current_user')
@admin.add_app_template_global
def utcnow() -> DatetimeWithTimezone:
"""Get current date.
"""
return DatetimeWithTimezone.utcnow()
@admin.app_template_filter('datetime')
def _format_datetime(date: datetime.datetime) -> str:
return date.strftime('%Y-%m-%d %T')
@admin.app_template_filter('nested_get')
from .models import Currency, Dispatcher, \
Order, OrderLine, Product, Store
from . import utilities
from .forms import StoreRegisterForm, ProductForm
from flw_module.forms import AccountDetailForm
from flw_module.models import AccountDetail
from flw_module.utilities import flw_subaccount
from factory import db
from users_module.forms import ProfileForm
from .utilities import can_edit_product, currency_options, latest_stores
# ---------- Declaring the blueprint ----------
shop = Blueprint('shop', __name__, template_folder='templates')
# Template accessible variables
shop.add_app_template_global(can_edit_product)
shop.add_app_template_global(currency_options)
shop.add_app_template_global(latest_stores)
@shop.before_request
def before_request():
''' Make sure that the currency is always known '''
if not (request.cookies.get('iso_code')):
response = make_response(redirect(request.path))
if (current_app.config['PRODUCT_PRICING'].split('-')[0]
not in ['localize', 'localize_market']):
code = current_app.config['PRODUCT_PRICING']
else:
try:
code = get('https://ipapi.co/currency/').text
