bbf6d9b026
Bugfix for feeds
- removed categories related and up
- load new books now working
- category random now working
login page is free of non accessible elements
boolean custom column is vivible in UI
books with only with certain languages can be shown
book shelfs can be deleted from UI
Anonymous user view is more resticted
Added browse of series in sidebar
Dependencys in vendor folder are updated to newer versions (licencs files are now present)
Bugfix editing Authors names
Made upload on windows working
265 lines
8.4 KiB
Python
265 lines
8.4 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
werkzeug.contrib.jsrouting
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Addon module that allows to create a JavaScript function from a map
|
|
that generates rules.
|
|
|
|
:copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
|
|
:license: BSD, see LICENSE for more details.
|
|
"""
|
|
try:
|
|
from simplejson import dumps
|
|
except ImportError:
|
|
try:
|
|
from json import dumps
|
|
except ImportError:
|
|
def dumps(*args):
|
|
raise RuntimeError('simplejson required for jsrouting')
|
|
|
|
from inspect import getmro
|
|
from werkzeug.routing import NumberConverter
|
|
from werkzeug._compat import iteritems
|
|
|
|
|
|
def render_template(name_parts, rules, converters):
|
|
result = u''
|
|
if name_parts:
|
|
for idx in range(0, len(name_parts) - 1):
|
|
name = u'.'.join(name_parts[:idx + 1])
|
|
result += u"if (typeof %s === 'undefined') %s = {}\n" % (name, name)
|
|
result += '%s = ' % '.'.join(name_parts)
|
|
result += """(function (server_name, script_name, subdomain, url_scheme) {
|
|
var converters = [%(converters)s];
|
|
var rules = %(rules)s;
|
|
function in_array(array, value) {
|
|
if (array.indexOf != undefined) {
|
|
return array.indexOf(value) != -1;
|
|
}
|
|
for (var i = 0; i < array.length; i++) {
|
|
if (array[i] == value) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function array_diff(array1, array2) {
|
|
array1 = array1.slice();
|
|
for (var i = array1.length-1; i >= 0; i--) {
|
|
if (in_array(array2, array1[i])) {
|
|
array1.splice(i, 1);
|
|
}
|
|
}
|
|
return array1;
|
|
}
|
|
function split_obj(obj) {
|
|
var names = [];
|
|
var values = [];
|
|
for (var name in obj) {
|
|
if (typeof(obj[name]) != 'function') {
|
|
names.push(name);
|
|
values.push(obj[name]);
|
|
}
|
|
}
|
|
return {names: names, values: values, original: obj};
|
|
}
|
|
function suitable(rule, args) {
|
|
var default_args = split_obj(rule.defaults || {});
|
|
var diff_arg_names = array_diff(rule.arguments, default_args.names);
|
|
|
|
for (var i = 0; i < diff_arg_names.length; i++) {
|
|
if (!in_array(args.names, diff_arg_names[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (array_diff(rule.arguments, args.names).length == 0) {
|
|
if (rule.defaults == null) {
|
|
return true;
|
|
}
|
|
for (var i = 0; i < default_args.names.length; i++) {
|
|
var key = default_args.names[i];
|
|
var value = default_args.values[i];
|
|
if (value != args.original[key]) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
function build(rule, args) {
|
|
var tmp = [];
|
|
var processed = rule.arguments.slice();
|
|
for (var i = 0; i < rule.trace.length; i++) {
|
|
var part = rule.trace[i];
|
|
if (part.is_dynamic) {
|
|
var converter = converters[rule.converters[part.data]];
|
|
var data = converter(args.original[part.data]);
|
|
if (data == null) {
|
|
return null;
|
|
}
|
|
tmp.push(data);
|
|
processed.push(part.name);
|
|
} else {
|
|
tmp.push(part.data);
|
|
}
|
|
}
|
|
tmp = tmp.join('');
|
|
var pipe = tmp.indexOf('|');
|
|
var subdomain = tmp.substring(0, pipe);
|
|
var url = tmp.substring(pipe+1);
|
|
|
|
var unprocessed = array_diff(args.names, processed);
|
|
var first_query_var = true;
|
|
for (var i = 0; i < unprocessed.length; i++) {
|
|
if (first_query_var) {
|
|
url += '?';
|
|
} else {
|
|
url += '&';
|
|
}
|
|
first_query_var = false;
|
|
url += encodeURIComponent(unprocessed[i]);
|
|
url += '=';
|
|
url += encodeURIComponent(args.original[unprocessed[i]]);
|
|
}
|
|
return {subdomain: subdomain, path: url};
|
|
}
|
|
function lstrip(s, c) {
|
|
while (s && s.substring(0, 1) == c) {
|
|
s = s.substring(1);
|
|
}
|
|
return s;
|
|
}
|
|
function rstrip(s, c) {
|
|
while (s && s.substring(s.length-1, s.length) == c) {
|
|
s = s.substring(0, s.length-1);
|
|
}
|
|
return s;
|
|
}
|
|
return function(endpoint, args, force_external) {
|
|
args = split_obj(args);
|
|
var rv = null;
|
|
for (var i = 0; i < rules.length; i++) {
|
|
var rule = rules[i];
|
|
if (rule.endpoint != endpoint) continue;
|
|
if (suitable(rule, args)) {
|
|
rv = build(rule, args);
|
|
if (rv != null) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (rv == null) {
|
|
return null;
|
|
}
|
|
if (!force_external && rv.subdomain == subdomain) {
|
|
return rstrip(script_name, '/') + '/' + lstrip(rv.path, '/');
|
|
} else {
|
|
return url_scheme + '://'
|
|
+ (rv.subdomain ? rv.subdomain + '.' : '')
|
|
+ server_name + rstrip(script_name, '/')
|
|
+ '/' + lstrip(rv.path, '/');
|
|
}
|
|
};
|
|
})""" % {'converters': u', '.join(converters),
|
|
'rules': rules}
|
|
|
|
return result
|
|
|
|
|
|
def generate_map(map, name='url_map'):
|
|
"""
|
|
Generates a JavaScript function containing the rules defined in
|
|
this map, to be used with a MapAdapter's generate_javascript
|
|
method. If you don't pass a name the returned JavaScript code is
|
|
an expression that returns a function. Otherwise it's a standalone
|
|
script that assigns the function with that name. Dotted names are
|
|
resolved (so you an use a name like 'obj.url_for')
|
|
|
|
In order to use JavaScript generation, simplejson must be installed.
|
|
|
|
Note that using this feature will expose the rules
|
|
defined in your map to users. If your rules contain sensitive
|
|
information, don't use JavaScript generation!
|
|
"""
|
|
from warnings import warn
|
|
warn(DeprecationWarning('This module is deprecated'))
|
|
map.update()
|
|
rules = []
|
|
converters = []
|
|
for rule in map.iter_rules():
|
|
trace = [{
|
|
'is_dynamic': is_dynamic,
|
|
'data': data
|
|
} for is_dynamic, data in rule._trace]
|
|
rule_converters = {}
|
|
for key, converter in iteritems(rule._converters):
|
|
js_func = js_to_url_function(converter)
|
|
try:
|
|
index = converters.index(js_func)
|
|
except ValueError:
|
|
converters.append(js_func)
|
|
index = len(converters) - 1
|
|
rule_converters[key] = index
|
|
rules.append({
|
|
u'endpoint': rule.endpoint,
|
|
u'arguments': list(rule.arguments),
|
|
u'converters': rule_converters,
|
|
u'trace': trace,
|
|
u'defaults': rule.defaults
|
|
})
|
|
|
|
return render_template(name_parts=name and name.split('.') or [],
|
|
rules=dumps(rules),
|
|
converters=converters)
|
|
|
|
|
|
def generate_adapter(adapter, name='url_for', map_name='url_map'):
|
|
"""Generates the url building function for a map."""
|
|
values = {
|
|
u'server_name': dumps(adapter.server_name),
|
|
u'script_name': dumps(adapter.script_name),
|
|
u'subdomain': dumps(adapter.subdomain),
|
|
u'url_scheme': dumps(adapter.url_scheme),
|
|
u'name': name,
|
|
u'map_name': map_name
|
|
}
|
|
return u'''\
|
|
var %(name)s = %(map_name)s(
|
|
%(server_name)s,
|
|
%(script_name)s,
|
|
%(subdomain)s,
|
|
%(url_scheme)s
|
|
);''' % values
|
|
|
|
|
|
def js_to_url_function(converter):
|
|
"""Get the JavaScript converter function from a rule."""
|
|
if hasattr(converter, 'js_to_url_function'):
|
|
data = converter.js_to_url_function()
|
|
else:
|
|
for cls in getmro(type(converter)):
|
|
if cls in js_to_url_functions:
|
|
data = js_to_url_functions[cls](converter)
|
|
break
|
|
else:
|
|
return 'encodeURIComponent'
|
|
return '(function(value) { %s })' % data
|
|
|
|
|
|
def NumberConverter_js_to_url(conv):
|
|
if conv.fixed_digits:
|
|
return u'''\
|
|
var result = value.toString();
|
|
while (result.length < %s)
|
|
result = '0' + result;
|
|
return result;''' % conv.fixed_digits
|
|
return u'return value.toString();'
|
|
|
|
|
|
js_to_url_functions = {
|
|
NumberConverter: NumberConverter_js_to_url
|
|
}
|