def handleFilters(query: Query, request_params: ImmutableDict)-> Query:
fromYear = request_params.get("fromYear", None)
toYear = request_params.get("toYear", None)
shape = request_params.get("shape", None)
if fromYear:
query = query.filter(Report.date >= year_to_date(fromYear))
if toYear:
query = query.filter(Report.date <= year_to_date(toYear))
if shape:
shapelist = shape.split(",")
shapelist = [shape.strip().upper() for shape in shapelist]
query = query.filter(func.upper(Report.shape).in_(shapelist))
return query
class Application:
default_config = {
"SESSION_TYPE": "redis",
"SESSION_COOKIE_NAME": "session",
"SESSION_KEY_PREFIX": "session:",
"SECRET_KEY": "secret",
"SESSION_LIFETIME": 60*10,
"REDIS_HOST": "127.0.0.1",
"REDIS_PORT": 6379,
"REDIS_PWD": None
}
session_interface_map = ImmutableDict({
"redis": RedisSessionInterface
})
secret_key = 'secret'
session_lifetime = 60*10
def __init__(
self,
config=None,
root_path=None,
static_folder='static',
template_folder='templates',
template_loader=None,
static_url_path='/static'
):
if config is None:
config = self.default_config
self.config = ImmutableDict(config)
for config in self.config:
setattr(self, config.lower(), self.config[config])
self.view_functions = dict()
self.handler_map = dict()
self.url_map = Map()
self.before_request_funcs = dict()
if root_path is None:
root_path = os.path.dirname(os.path.abspath('<input>'))
self.root_path = root_path
self.static_folder = static_folder
self.template_folder = template_folder
self.static_url_path = static_url_path
self.jinja_loader = template_loader
self.jinja_env = self.create_jinja_env()
self.session_interface = self.get_interface()
self.add_url_rule(self.static_url_path+"/<path:filename>", endpoint='static', view_func=self.send_static_file)
def wsgi_app(self, environ, start_response):
local.request = Request(environ, self)
local.current_app = self
local.g = Global()
local.session = self.session_interface.open_session(self, request)
resp = self.full_dispatch_request()
iterable = resp(environ, start_response)
return iterable
def send_static_file(self, filename):
return send_from_directory(self.static_folder, filename)
def before_request(self, endpoint=None):
def decorator(f):
self.before_request_funcs.setdefault(endpoint, []).append(f)
return f()
# 为了让before_request不用加( )而加的傻逼东西，迟早删了
if type(endpoint) is not str:
self.before_request_funcs.setdefault(None, []).append(endpoint)
return decorator
def add_before_request_func(self, func, endpoint=None):
self.before_request_funcs.setdefault(endpoint, []).append(func)
def preprocess_request(self):
endpoint = request.url_rule.endpoint if request.url_rule is not None else None
funcs = self.before_request_funcs.get(None, [])
if endpoint is not None:
for func in self.before_request_funcs.get(endpoint, ()):
funcs.append(func)
for func in funcs:
rv = func()
if rv is not None:
return rv
def register_error_handler(self, exc_class_or_code, handler):
exc_class = _find_exceptions(exc_class_or_code)
if isinstance(exc_class, Exception):
raise ValueError("Handler can only be registered for exception classes, not instance")
self.handler_map[exc_class] = handler
def route(self, path, **options):
def decorator(f):
self.add_url_rule(path, f, **options)
return f
return decorator
def error_handler(self, exc_class):
def decorator(f):
self.register_error_handler(exc_class, f)
return f
return decorator
def add_url_rule(self, path, view_func, endpoint=None, methods=None):
if endpoint is None:
endpoint = view_func.__name__
old_func = self.view_functions.get(endpoint, None)
if old_func is not None and old_func != view_func:
raise AssertionError(
"View function mapping is overwriting an "
"existing endpoint function: %s" % endpoint
)
if methods is None:
methods = getattr(view_func, "methods", None) or ("GET",)
rule = Rule(path, endpoint=endpoint, methods=methods)
self.url_map.add(rule)
self.view_functions[endpoint] = view_func
# match the commented out MethodView
# def add_method_view(self, path, method_view, endpoint=None):
# if endpoint is None:
# endpoint = method_view.__name__
#
# old_view = self.view_functions.get(endpoint, None)
# if old_view is not None and old_view != method_view:
# raise AssertionError(
# "View function mapping is overwriting an "
# "existing endpoint function(MethodView): %s" % endpoint
# )
#
# rule = Rule(path, endpoint=endpoint, methods=method_view.methods)
# self.url_map.add(rule)
# self.view_functions[endpoint] = method_view
def dispatch_request(self):
# return value from view_function
if request.routing_exception is not None:
raise request.routing_exception
rule = request.url_rule
return self.view_functions[rule.endpoint](**request.view_args)
def full_dispatch_request(self):
# return a Response object
try:
resp = self.preprocess_request()
if resp is None:
resp = self.dispatch_request()
except Exception as e:
resp = self.handler_exceptions(e)
return self.finalize_request(resp)
def finalize_request(self, resp):
if isinstance(resp, BaseResponse) or callable(resp):
resp = resp
else:
resp = Response(resp)
self.session_interface.save_session(session, resp, self.session_lifetime)
return resp
def handler_exceptions(self, e):
exc_type = type(e)
if exc_type in self.handler_map:
handler = self.handler_map.get(exc_type)
return handler(e)
elif issubclass(exc_type, HTTPException):
return e
else:
raise e
def get_interface(self):
session_type = self.config.get("SESSION_TYPE", 'redis')
interface_class = self.session_interface_map[session_type]
return interface_class(self)
def render_template(self, template_name, **kws):
template = self.jinja_env.get_template(template_name)
return Response(template.render(**kws), content_type='text/html')
def create_jinja_env(self):
if self.jinja_loader is None:
self.jinja_loader = FileSystemLoader(os.path.join(self.root_path, self.template_folder))
env = Environment(loader=self.jinja_loader)
env.globals.update(
url_for=url_for,
config=self.config,
request=request,
g=g,
session=session
)
return env
def __call__(self, environ, start_response):
return self.wsgi_app(environ, start_response)
def read_from_form(self, form: ImmutableDict):
super().read_from_form(form)
domain = form.get('domain', None)
if domain is not None and domain != "":
self.name = domain
def read_from_form(self, form: ImmutableDict):
for x in self.ATTRS:
res = form.get(x, None)
if res == "":
res = None
setattr(self, x, res)
