def __init__(self,
name,
import_name,
url_prefix=None,
config=None,
breadcrumbs=None,
menubuilder=None,
force_https=False,
**kwargs):
"""
Invenio extension of standard Flask blueprint.
@param name: blueprint unique text identifier
@param import_name: class name (usually __name__)
@param url_prefix: URL prefix for all blueprints' view functions
@param config: importable config class
@param breadcrumbs: list of breadcrumbs
@param menubuilder: list of menus
@param force_https: requires blueprint to be accessible only via https
"""
Blueprint.__init__(self,
name,
import_name,
url_prefix=url_prefix,
**kwargs)
self.config = config
self.breadcrumbs = breadcrumbs or []
self.breadcrumbs_map = {}
self.menubuilder = menubuilder or []
self.menubuilder_map = {}
self._force_https = force_https
def __init__(self,
name='partnership',
import_name=__name__,
*args,
**kwargs):
Blueprint.__init__(self,
name,
import_name,
template_folder='templates',
*args,
**kwargs)
self.add_url_rule('/partnership/<int:id>',
'view_partnership',
view,
methods=['GET'])
self.add_url_rule('/partnership',
'new_partnership',
new,
methods=['GET'])
self.add_url_rule('/partnership',
'create_partnership',
create,
methods=['POST'])
self.add_url_rule('/partnership/<int:id>',
'update_partnership',
update,
methods=['POST'])
self.add_url_rule('/delpartnership/<int:id>',
'delete_partnership',
delete,
methods=['POST'])
self.add_url_rule('/partnerships',
'partnerships',
list,
methods=['GET'])
def __init__(self, name=None, import_name=__name__, **kwargs):
name = self.__class__.__name__ if name is None else name # 默认为类名
Blueprint.__init__(self, name, import_name, **kwargs)
RouterInterface.__init__(self)
self._sub_router_table = {} # 子路由表 {str: Router, ...}
def __init__(
self,
import_name,
static_folder=None,
static_url_path=None,
template_folder=None,
url_prefix=None,
subdomain=None,
url_defaults=None,
root_path=None,
login_url=None,
authorized_url=None,
backend=None,
):
Blueprint.__init__(
self,
name="webfinger",
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
url_defaults=url_defaults,
root_path=root_path,
)
self._managers = []
self.add_url_rule(rule="/webfinger", endpoint="webfinger", view_func=self.handler)
def __init__(
self,
import_name,
static_folder=None,
static_url_path=None,
template_folder=None,
url_prefix=None,
subdomain=None,
url_defaults=None,
root_path=None,
login_url=None,
authorized_url=None,
backend=None,
):
Blueprint.__init__(
self,
name="webfinger",
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
url_defaults=url_defaults,
root_path=root_path,
)
self._managers = []
self.add_url_rule(rule="/webfinger",
endpoint="webfinger",
view_func=self.handler)
def __init__(self,
name='apilog',
import_name=__name__,
url_prefix="",
*args,
**kwargs):
Blueprint.__init__(self,
name,
import_name,
url_prefix=url_prefix,
*args,
**kwargs)
self.add_url_rule('/logs', 'get_logs', get_logs, methods=['GET'])
self.add_url_rule('/log/<endpoint>',
'get_log',
get_log,
methods=['GET'])
self.add_url_rule('/log/<endpoint>',
'set_log',
set_log,
methods=['PUT'])
self.add_url_rule('/log/<endpoint>',
'rm_log',
rm_log,
methods=['DELETE'])
def __init__(self, name='auth', import_name=__name__, *args, **kwargs):
Blueprint.__init__(self,
name,
import_name,
template_folder='templates',
*args,
**kwargs)
self.before_app_first_request(self._init)
self.add_url_rule('/logout', 'logout', logout, methods=['GET'])
self.add_url_rule('/login', 'login', login, methods=['POST', 'GET'])
self.add_url_rule('/currentuser',
'currentuser',
currentuser,
methods=['GET'])
self.add_url_rule('/user/<int:id>',
'view_user',
view_user,
methods=['GET'])
self.add_url_rule('/user', 'new_user', new_user, methods=['GET'])
self.add_url_rule('/user',
'create_user',
create_user,
methods=['POST'])
self.add_url_rule('/user/<int:id>',
'update_user',
update_user,
methods=['POST'])
self.add_url_rule('/deluser/<int:id>',
'delete_user',
delete_user,
methods=['POST'])
self.add_url_rule('/users', 'users', users, methods=['GET'])
def __init__(self, name="base", **kwargs):
Blueprint.__init__(self,
name,
__name__,
template_folder="templates",
static_folder="base",
**kwargs)
def __init__(self, name, import_name, **kwargs):
self.required_permission = None
if 'required_permission' in kwargs:
self.required_permission = kwargs['required_permission']
del (kwargs['required_permission'])
oBlueprint.__init__(self, name, import_name, **kwargs)
def __init__(self, name, mongo):
Blueprint.__init__(self, name, __name__)
self.mongo = mongo
self.add_url_rule('', 'get_items', self.get_items, methods=['GET'])
self.add_url_rule('/<item_id>', 'get_item', self.get_item, methods=['GET'])
self.add_url_rule('', 'create_item', self.create_item, methods=['POST'])
self.add_url_rule('/<item_id>', 'update_item', self.update_item, methods=['PUT'])
self.add_url_rule('/<item_id>', 'delete_item', self.delete_item, methods=['DELETE'])
def __init__(self, name, import_name, **kwargs):
self.required_permission = None
if 'required_permission' in kwargs:
self.required_permission = kwargs['required_permission']
del(kwargs['required_permission'])
oBlueprint.__init__(self, name, import_name, **kwargs)
def __init__(self, name='info', import_name=__name__, *args, **kwargs):
Blueprint.__init__(self,
name,
import_name,
template_folder='templates',
*args,
**kwargs)
self.add_url_rule('/info', 'info', info, methods=['GET'])
def __init__(self, name, import_name, template_folder=None):
Blueprint.__init__(self, name, import_name, template_folder=template_folder)
# allows usage of route descriptor
for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
if hasattr(method, "routes"):
for rule, options in method.routes:
self.route(rule, **options)(method)
def __init__(self, **kwargs):
Blueprint.__init__(
self,
"webcomponents",
__name__,
static_folder="webcomponents",
template_folder="templates",
**kwargs
)
def __init__(self, *args, **kwargs):
if "dup_on_startswith" in kwargs:
ds = kwargs.pop("dup_on_startswith")
if isinstance(ds, basestring) or not hasattr(ds, "__iter__"):
self._dup_on_startswith = {ds}
else:
self._dup_on_startswith = set(ds)
Blueprint.__init__(self, *args, **kwargs)
self.decorators = {}
def __init__(self, name, route, idx):
root_path = os.path.join(levels_root, name)
Blueprint.__init__(self,
name,
import_name=__name__,
static_folder=os.path.join(root_path, 'static'),
template_folder=levels_root)
self.root_path = root_path
self.name = name
self.route_ = route
self.routeidx = idx
self.number = idx + 1
self.root_path = os.path.join(levels_root, name)
gbls = dict([(i, globals()[i]) for i in self.LEVEL_GLOBALS])
gbls['level'] = self
def _render_template(name, **context):
context['level'] = self
context['route'] = self.route_
context['solvers'] = get_solvers(self.config, self)
return render_template('%s/%s' % (self.name, name), **context)
gbls['render_template'] = _render_template
gbls['case_sensitive'] = None
self.level = runpy.run_module('levels.%s.level' % name, gbls)
for i in self.LEVEL_ITEMS:
if i in self.level:
self.__dict__[i] = self.level[i]
if isinstance(self.author, list) or isinstance(self.author, tuple):
self.author_text = ' & '.join(self.author)
else:
self.author_text = self.author
if 'index' not in self.level:
@self.route('/')
def index():
return _render_template('index.html')
self.index = index
@self.route('/solve', methods=['POST'])
def solve():
password = None
if 'password' in request.form:
password = request.form['password']
return self.solve(password)
@self.route('/skip', methods=['POST'])
def skip():
return self.skip()
@self.before_request
def check_perms():
if self.state() == 'closed':
self.logger.warning('[%s][%s] level forbidden', g.user,
self.name)
return render_template('forbidden.html'), 403
def __init__(self):
Blueprint.__init__(self, 'contact_us', __name__, url_prefix='/contact_us',
template_folder='views',
static_folder='static',
static_url_path='/static/home')
@self.route('/', methods=['GET'])
def api_index():
return render_template("contact_us_index.html")
def __init__(
self,
name,
import_name,
actor_manager,
base_url=None,
static_folder=None,
static_url_path=None,
template_folder=None,
url_prefix=None,
subdomain=None,
url_defaults=None,
root_path=None,
login_url=None,
authorized_url=None,
backend=None,
):
Blueprint.__init__(
self,
name=name,
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
url_defaults=url_defaults,
root_path=root_path,
)
base_url = base_url or f"/"
actor_url = f"{base_url}/<actor_id>"
inbox_url = f"{actor_url}/inbox"
outbox_url = f"/{actor_url}/outbox"
followers_url = f"/{actor_url}/followers"
following_url = f"/{actor_url}/following"
self.add_url_rule(rule=actor_url,
endpoint="actor",
view_func=self.actor)
self.add_url_rule(rule=inbox_url,
endpoint="inbox",
view_func=self.inbox,
methods=("POST", ))
self.add_url_rule(rule=outbox_url,
endpoint="outbox",
view_func=self.outbox)
self.add_url_rule(rule=followers_url,
endpoint="followers",
view_func=self.followers)
self.add_url_rule(rule=following_url,
endpoint="following",
view_func=self.following)
self.manager = actor_manager
def __init__(self, name='static', import_name=__name__, url_prefix="", path='.', *args, **kwargs):
"""
BlueStatic
Blueprint module for static web
:param path: The path of directory sharing
:type path: str
"""
Blueprint.__init__(self, name, import_name, url_prefix=url_prefix, *args, **kwargs)
path = abspath(path)
self.add_url_rule('/<path:filename>', 'static_web', add_path(path)(static_web))
self.add_url_rule('/', 'static_web_index', add_path(path)(static_web_index))
def __init__(self, name='logmanager', import_name=__name__, ui_testing=False, url_prefix="", by_rule=True, level=None, *args, **kwargs):
Blueprint.__init__(self, name, import_name, url_prefix=url_prefix, *args, **kwargs)
self._level = level
self.add_url_rule('/loggers', 'get_loggers', get_loggers, methods=['GET'])
self.add_url_rule('/logger/<loggerId>', 'get_logger', get_logger, methods=['GET'])
self.add_url_rule('/logger/<loggerId>', 'set_logger', set_logger, methods=['PUT'])
if ui_testing:
self.add_url_rule('/ui/<path:filename>', 'static_web', static_web)
self.add_url_rule('/ui/', 'static_web_index', static_web_index)
if by_rule:
self.before_app_first_request(self._add_dynamics_logger)
def __init__(self, name='synth', import_name=__name__, *args, **kwargs):
Blueprint.__init__(self,
name,
import_name,
template_folder='templates',
*args,
**kwargs)
self.add_url_rule('/synth', 'synth', view, methods=['GET'])
self.authorization = [
'voir',
]
def __init__(self, name='book', import_name=__name__, dir_books="./files/uploads/book", *args, **kwargs):
Blueprint.__init__(self, name, import_name, template_folder='templates', *args, **kwargs)
self.before_app_first_request(self._init)
self.dir_books = dir_books
self.add_url_rule('/book/<int:id>', 'view_book', view, methods=['GET'])
self.add_url_rule('/book', 'new_book', new, methods=['GET'])
self.add_url_rule('/book', 'create_book', create, methods=['POST'])
self.add_url_rule('/book/<int:id>', 'update_book', update, methods=['POST'])
self.add_url_rule('/delbook/<int:id>', 'delete_book', delete, methods=['POST'])
self.add_url_rule('/books', 'books', list, methods=['GET'])
self.add_url_rule('/uploads/<path:filename>', 'static_web', static_web_uploads)
self.authorization = ['voir', 'ajouter modifier', 'supprimer']
def __init__(self, name='note', import_name=__name__, *args, **kwargs):
Blueprint.__init__(self, name, import_name, template_folder='templates', *args, **kwargs)
self.add_url_rule('/note/<int:id>', 'view_note', view, methods=['GET'])
self.add_url_rule('/note', 'new_note', new, methods=['GET'])
self.add_url_rule('/note', 'create_note', create, methods=['POST'])
self.add_url_rule('/note/<int:id>', 'update_note', update, methods=['POST'])
self.add_url_rule('/delnote/<int:id>', 'delete_note', delete, methods=['POST'])
self.add_url_rule('/notes', 'notes', listing, methods=['GET'])
self.add_url_rule('/wizardnote', 'wizard_note', wizardnoteview, methods=['GET'])
self.add_url_rule('/wizardnote', 'wizard_new_note', wizardnotecreate, methods=['POST'])
self.add_url_rule('/note/description/<int:idbook>/<int:iduser>', 'description_note', getdescription, methods=['GET'])
self.authorization = ['note rapide', 'voir', 'ajouter modifier', 'supprimer']
def __init__(self, name='homepage', import_name=__name__, *args, **kwargs):
Blueprint.__init__(self,
name,
import_name,
template_folder='templates',
*args,
**kwargs)
self.add_url_rule('/homepage', 'view', view, methods=['GET'])
self.add_url_rule('/homepage',
'update_homepage',
update,
methods=['POST'])
def __init__(self, get_frame=None, message_handlers={}, **kwargs):
Blueprint.__init__(self,
"controller",
__name__,
template_folder="templates",
static_folder="static",
**kwargs)
self.base_blueprint = BaseBlueprint()
self.components_blueprint = WebComponentsBlueprint()
self.video_blueprint = VideoBlueprint(get_frame=get_frame)
self.messaging_blueprint = MessagingBlueprint(
message_handlers=message_handlers)
def __init__(self, name="video", get_frame=None, **kwargs):
Blueprint.__init__(
self,
name,
__name__,
static_folder="video",
template_folder="templates",
**kwargs,
)
@self.route(f"/{name}.mjpg")
def video():
return VideoResponse(get_frame=get_frame)
def __init__(self, message_handlers={}, **kwargs):
Blueprint.__init__(
self,
"messaging",
__name__,
static_folder="messaging",
template_folder="templates",
**kwargs,
)
def handle_message(message, send):
parsed_message = json.loads(message)
message_type = parsed_message.get("type", "")
message_data = parsed_message.get("data")
handler = message_handlers.get(message_type)
if handler is None:
log_unhandled_message(message_type, message_data)
return
spec = getfullargspec(handler)
if len(spec.args) == (3 if ismethod(handler) else 2) or spec.varargs:
handler(message_data, send)
return
if len(spec.args) == (2 if ismethod(handler) else 1):
handler(message_data)
return
handler()
self.sockets = {}
self.socket_blueprint = Blueprint("messaging_socket", __name__)
@self.socket_blueprint.route("/messaging")
def pubsub(ws):
id = time()
self.sockets[id] = ws
def send(response_message):
ws.send(json.dumps(response_message))
while not ws.closed:
message = ws.receive()
if message:
handle_message(message, send)
del self.sockets[id]
def __init__(self, name, config: dict, path: str, module_route=None):
if module_route is None:
module_route = ""
self.module_route = module_route
template_folder, static_folder, static_url = self.get_paths(
config, path)
Blueprint.__init__(self,
name,
name,
static_url_path=static_url,
static_folder=static_folder,
template_folder=template_folder)
WebsiteAppBase.__init__(self, config, path=path)
def __init__(self):
Blueprint.__init__(self, 'help', __name__, url_prefix='/help',
template_folder='views',
static_folder='static',
static_url_path='/static/home')
@self.route('/', methods=['GET'])
def api_index():
try:
parsed_uri = urlparse(request.referrer)
domain = '{uri.scheme}://{uri.netloc}/'.format(uri=parsed_uri)
except:
domain = app.config['BASE_URL'] + '/'
return render_template("help_index.html", domain=domain)
def __init__(self):
Blueprint.__init__(self, 'api', __name__, url_prefix='/api',
template_folder='views',
static_folder='static',
static_url_path='/static/home')
@self.route('/', methods=['GET'])
def api_index():
try:
parsed_uri = urlparse(request.referrer)
domain = '{uri.scheme}://{uri.netloc}/'.format(uri=parsed_uri)
except:
domain = app.config['BASE_URL'] + '/'
return render_template("api_index.html", domain=domain)
@self.route('/damage/progress/<path:uri>', methods=['GET'])
def api_damage_progress(uri):
start = request.args.get('start', '0')
start = int(start)
hashed_uri = md5(uri).hexdigest()
quoted_url = urllib.quote(uri).replace('/', '_').replace('.', '-')
lines_to_send = []
app_log_file = os.path.join(app.config['CACHE_DIR'], quoted_url, 'app.log')
if os.path.exists(app_log_file):
with open(app_log_file, 'rb') as f:
for idx, line in enumerate(f.readlines()):
if idx >= start:
lines_to_send.append(line.strip())
return Response(response=json.dumps(lines_to_send), status=200, mimetype='application/json')
@self.route('/damage/error/<path:uri>', methods=['GET'])
def api_damage_error(uri):
hashed_uri = md5(uri).hexdigest()
quoted_url = urllib.quote(uri).replace('/', '_').replace('.', '-')
result_file = os.path.join(app.config['CACHE_DIR'], quoted_url, 'result.json')
if os.path.exists(result_file):
try:
result = json.load(open(result_file))
return Response(response=json.dumps(result), status=200, mimetype='application/json')
except Exception, e:
return Response(response=json.dumps({'error': True, 'message': e.message}), status=200,
mimetype='application/json')
return Response(response=json.dumps({'error': False}), status=200, mimetype='application/json')
def __init__(self, name='search', import_name=__name__, *args, **kwargs):
Blueprint.__init__(self,
name,
import_name,
template_folder='templates',
*args,
**kwargs)
self.add_url_rule('/search', 'search', search, methods=['GET'])
self.add_url_rule('/search',
'searchsuits',
searchsuits,
methods=['POST'])
self.add_url_rule('/search/<int:id>',
'searchsuit',
searchsuit,
methods=['GET'])
def __init__(self, name, modname):
Blueprint.__init__(self, name, modname, url_prefix="/mod" + name, template_folder='templates')
self._menus = {}
self._side_menus = {}
self._name = name
self._mod_name = modname
self._side_menu_roles = {}
self._menus_html = {}
self._side_menus_html = {}
@ajax.route(self,"/ajax")
def __sijax_handler():
if g.sijax.is_sijax_request:
return g.sijax.process_request()
return "fail."
def __init__(self,
name='paramapplication',
import_name=__name__,
*args,
**kwargs):
Blueprint.__init__(self,
name,
import_name,
template_folder='templates',
*args,
**kwargs)
self.add_url_rule('/settings', 'view', view, methods=['GET'])
self.add_url_rule('/settings',
'update_settings',
update,
methods=['POST'])
def __init__(self, name, import_name, direct_name="Ext.app.REMOTING_API", namespace="Ext.app", **kw):
"""ExtDirectBlueprint
:param name:
:param import_name:
:param direct_name: name of the remoting API JS variable
:param namespace: JS namespace to define
"""
self.logger.debug("ExtDirectBlueprint: name=%s import_name=%s direct_name=%s namespace=%s",
name, import_name, direct_name, namespace)
self.direct_name = direct_name
self.namespace = namespace
self.defs = {}
self.registry = {}
Blueprint.__init__(self, name, import_name, **kw)
def __init__(self, name='history', import_name=__name__, archives="./archives", *args, **kwargs):
Blueprint.__init__(self, name, import_name, template_folder='templates', *args, **kwargs)
self.archives_path = os.path.abspath(archives)
self.add_url_rule('/history', 'history', add_path(self.archives_path)(history), methods=['GET'])
self.add_url_rule('/addhistory', 'addhistory', add_path(self.archives_path)(addhistory), methods=['GET'])
if os.path.isfile(self.archives_path) is False:
if os.path.isdir(self.archives_path) is False:
try:
os.mkdir(self.archives_path)
except Exception as err:
logging.error("no possible to create %s" % self.archives_path)
raise err
else:
raise ValueError("no possible to create %s" % self.archives_path)
self.add_url_rule('/archives/<path:filename>', 'static_web', add_path(self.archives_path)(static_web))
self.authorization = ['voir','ajouter']
def __init__(self,
name='up',
import_name=__name__,
dir_uploads="./files/uploads/import",
*args,
**kwargs):
Blueprint.__init__(self,
name,
import_name,
template_folder='templates',
*args,
**kwargs)
self.before_app_first_request(self._init)
self.dir_uploads = dir_uploads
self.add_url_rule('/up', 'up', view, methods=['GET'])
self.add_url_rule('/up', 'upload', upload, methods=['POST'])
self.add_url_rule('/purge', 'purge', purge, methods=['POST'])
def __init__(
self,
name,
import_name,
actor_manager,
base_url=None,
static_folder=None,
static_url_path=None,
template_folder=None,
url_prefix=None,
subdomain=None,
url_defaults=None,
root_path=None,
login_url=None,
authorized_url=None,
backend=None,
):
Blueprint.__init__(
self,
name=name,
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
url_defaults=url_defaults,
root_path=root_path,
)
base_url = base_url or f"/"
actor_url = f"{base_url}/<actor_id>"
inbox_url = f"{actor_url}/inbox"
outbox_url = f"/{actor_url}/outbox"
followers_url = f"/{actor_url}/followers"
following_url = f"/{actor_url}/following"
self.add_url_rule(rule=actor_url, endpoint="actor", view_func=self.actor)
self.add_url_rule(rule=inbox_url, endpoint="inbox", view_func=self.inbox, methods=("POST",))
self.add_url_rule(rule=outbox_url, endpoint="outbox", view_func=self.outbox)
self.add_url_rule(rule=followers_url, endpoint="followers", view_func=self.followers)
self.add_url_rule(rule=following_url, endpoint="following", view_func=self.following)
self.manager = actor_manager
def __init__(self):
Blueprint.__init__(self,
'help',
__name__,
url_prefix='/help',
template_folder='views',
static_folder='static',
static_url_path='/static/home')
@self.route('/', methods=['GET'])
def api_index():
try:
parsed_uri = urlparse(request.referrer)
domain = '{uri.scheme}://{uri.netloc}/'.format(uri=parsed_uri)
except:
domain = app.config['BASE_URL'] + '/'
return render_template("help_index.html", domain=domain)
def __init__(self,
name='bluelogin',
import_name=__name__,
ui_testing=False,
url_prefix="",
group_name='admin',
*args,
**kwargs):
Blueprint.__init__(self,
name,
import_name,
url_prefix=url_prefix,
*args,
**kwargs)
self._add_check_login_list = []
self._grp = group_name
self._add_url_rule(ui_testing)
self.before_app_first_request(self._init_login_manager)
def __init__(self, *args, **kwargs):
url_prefix = kwargs.get("url_prefix", "")
if kwargs.pop("set_community_id_prefix", True):
if (not url_prefix) or url_prefix[0] != "/":
url_prefix = "/" + url_prefix
url_prefix = self._ROUTE_PARAM + url_prefix
if not url_prefix.startswith(self._BASE_URL_PREFIX):
if (not url_prefix) or url_prefix[0] != "/":
url_prefix = "/" + url_prefix
url_prefix = self._BASE_URL_PREFIX + url_prefix
if url_prefix[-1] == "/":
url_prefix = url_prefix[:-1]
kwargs["url_prefix"] = url_prefix
BaseBlueprint.__init__(self, *args, **kwargs)
self.url_value_preprocessor(pull_community)
self.url_value_preprocessor(init_current_tab)
self.before_request(check_access)
def __init__(self, name, import_name, allowed_roles=None, **kwargs):
"""
:param roles: role or list of roles required to access any view in this
blueprint.
"""
BaseBlueprint.__init__(self, name, import_name, **kwargs)
if allowed_roles is not None:
if isinstance(allowed_roles, string_types):
allowed_roles = Role(allowed_roles)
if isinstance(allowed_roles, Role):
allowed_roles = (allowed_roles,)
else:
allowed_roles = ()
if allowed_roles:
self.record_once(lambda s:
s.app.add_access_controller(
self.name,
allow_access_for_roles(allowed_roles))
)
def __init__(self, controller, static_files=False):
Blueprint.__init__(self, 'MentorFinderViews', __name__)
self.controller = controller
self.add_url_rules()
if static_files:
self.add_static_files()
def __init__(self, *args, **kwargs):
Blueprint.__init__(self, *args, **kwargs)
RemoteObject.__init__(self)
self.registerObjMethods(self)
def __init__(self, *args, **kwargs):
Blueprint.__init__(self, *args, **kwargs)
self.__all.append(self)
def __init__(self):
Blueprint.__init__(self, 'provisional', __name__)
self.provisional = None
SSLify(self)
def __init__(self, *args, **kwargs):
Blueprint.__init__(self, *args, **kwargs)
self.decorators = {}
def __init__(self, *args, **kwargs):
Blueprint.__init__(self, *args, **kwargs)
def __init__(self, name, import_name, **kw):
kw['static_folder'] = 'static'
kw['template_folder'] = 'templates'
Blueprint.__init__(self, name, import_name, **kw)
def __init__(self, *args, **kwargs):
self.domain = kwargs.pop("domain") if "domain" in kwargs else None
Blueprint.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
Blueprint.__init__(self, *args, **kwargs)
self.children = []
def __init__(self, name, import_name, **kw):
kw["static_folder"] = "../static/" + name
Blueprint.__init__(self, name, import_name, **kw)
