def access_controlled_app(app):
"""
An app where all the routes are access-controlled to the 'buyer' role, and there are some login routes if we need.
"""
login_manager = LoginManager()
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
# simulate loading a user from the API
return User.from_json({"users": USERS[user_id]})
app.register_blueprint(login_for_tests)
app.secret_key = 'secret'
main = Blueprint('main', 'main')
@main.route('/')
def simple_route():
return "Hello"
main.before_request(functools.partial(require_login, role='buyer'))
app.register_blueprint(main)
return app
def blueprint():
bp = Blueprint('locks', __name__, url_prefix='/locks')
lock_by_rse_view = LockByRSE.as_view('lock_by_rse')
bp.add_url_rule('/<rse>', view_func=lock_by_rse_view, methods=[
'get',
])
lock_by_scope_name_view = LocksByScopeName.as_view('locks_by_scope_name')
bp.add_url_rule('/<path:scope_name>',
view_func=lock_by_scope_name_view,
methods=[
'get',
])
locks_for_dids_view = DatasetLocksForDids.as_view('locks_for_dids')
bp.add_url_rule('/bulk_locks_for_dids',
view_func=locks_for_dids_view,
methods=[
'post',
])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def create_app(name=__name__, config=None, skip_defaults=False):
"""
app factory
If config is not passed, env is inspected for 'APP_CONFIG'. If not present,
the base defaults from settings.BaseConfig apply (local server, etc)
"""
app = Flask(name)
if not config:
log.warning("Using default config")
config = Config()
app.config.from_object(config)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.add_namespace(healthcheck_namespace)
api.add_namespace(activities_namespace)
api.add_namespace(blobs_namespace)
api.add_namespace(items_namespace)
init_app(app)
api.init_app(blueprint)
blueprint.before_request(setup_db)
app.register_blueprint(blueprint)
got_request_exception.connect(drop_into_pdb)
try:
if '-echo' in str(subprocess.check_output("stty", shell=True)):
log.debug("Re-enabling echo w/ stty")
subprocess.check_call("stty echo", shell=True)
except subprocess.CalledProcessError:
pass
return app
def set_up_view(app: Flask):
mod = Blueprint('', __name__)
mod.add_url_rule(
'',
view_func=RadioView.as_view('RadioView'),
)
mod.add_url_rule(
'history',
view_func=RadioHistoryView.as_view('RadioHistoryView'),
)
mod.add_url_rule(
'login',
view_func=LoginView.as_view('LoginView'),
)
mod.add_url_rule(
'logout',
view_func=LogoutView.as_view('LogoutView'),
)
mod.before_request(g_login)
# Реєстрація блюпрінта
app.register_blueprint(mod, url_prefix='/')
class Playground(object):
def __init__(self, app, auth_func=None, setup=True):
self.app = app
self.blueprint = Blueprint('playground', __name__,
template_folder='templates')
if auth_func:
self.blueprint.before_request(auth_func)
self.blueprint.route('/')(self.index)
if setup:
self.setup()
def index(self):
endpoints = self.get_endpoints().values()
endpoints.sort(key=itemgetter('url'))
blueprints = current_app.blueprints.keys()
return render_template('playground/index.html',
blueprints=blueprints, endpoints=endpoints)
def setup(self):
self.blueprint.route('/')(self.index)
self.app.register_blueprint(self.blueprint,
url_prefix='/playground')
@property
def route(self):
return self.blueprint.route
def get_endpoints(self, blueprint=None):
endpoints = {}
for rule in current_app.url_map.iter_rules():
if blueprint and not rule.endpoint.startswith(blueprint + '.'):
continue
func = current_app.view_functions[rule.endpoint]
docstring = inspect.getdoc(func)
spec = inspect.getargspec(func)
if spec.args:
defaults = spec.defaults or []
defaults = [None]*(len(spec.args)-len(defaults))+list(defaults)
args = dict(zip(spec.args, defaults))
else:
args = []
endpoints[str(rule)] = {
'endpoint': rule.endpoint,
'blueprint': rule.endpoint.split('.')[0] if '.' in rule.endpoint else '.',
'url': str(rule),
'methods': list(rule.methods),
'args': args,
'defaults': rule.defaults,
'headers': '',
'description': docstring,
}
return endpoints
def blueprint():
bp = Blueprint('identities', __name__, url_prefix='/identities')
userpass_view = UserPass.as_view('userpass')
bp.add_url_rule('/<account>/userpass',
view_func=userpass_view,
methods=[
'put',
])
x509_view = X509.as_view('x509')
bp.add_url_rule('/<account>/x509', view_func=x509_view, methods=[
'put',
])
gss_view = GSS.as_view('gss')
bp.add_url_rule('/<account>/gss', view_func=gss_view, methods=[
'put',
])
accounts_view = Accounts.as_view('accounts')
bp.add_url_rule('/<identity_key>/<type>/accounts',
view_func=accounts_view,
methods=[
'get',
])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def create_blueprint(name, import_name, before_request=None, **kwargs):
kwargs.setdefault('url_prefix', '/mine')
bp = Blueprint('mine.%s' % name, import_name, **kwargs)
if not before_request:
before_request = _before_request
bp.before_request(before_request)
return bp
def _factory(
partial_module_string: str,
url_prefix: str,
auth_function: Callable | None = None,
new_endpoint: str | None = None,
) -> Blueprint:
"""Generate a blueprint registration."""
# Build out the module import path
endpoint_folder = "public" if auth_function is None else "protected"
import_name = [
"src",
"blueprints",
"v1",
endpoint_folder,
partial_module_string,
]
import_path: str = ".".join(import_name)
# Actually create the blueprint
blueprint = Blueprint(partial_module_string,
import_path,
url_prefix=f"/v1/{url_prefix}")
# Protect the endpoint with an authorization routine
# if one was given
if auth_function is not None:
blueprint.before_request(auth_function)
# This endpoint has been deprecated, attach a HTTP header
# stating this and transition info
if new_endpoint is not None:
x = partial(send_deprecation_warning, new_endpoint)
blueprint.after_request(x) # type: ignore
return blueprint
def blueprint():
bp = Blueprint('requests', __name__, url_prefix='/requests')
request_get_view = RequestGet.as_view('request_get')
bp.add_url_rule('/<path:scope_name>/<rse>',
view_func=request_get_view,
methods=[
'get',
])
request_history_get_view = RequestHistoryGet.as_view('request_history_get')
bp.add_url_rule('/history/<path:scope_name>/<rse>',
view_func=request_history_get_view,
methods=[
'get',
])
request_list_view = RequestList.as_view('request_list')
bp.add_url_rule('/list', view_func=request_list_view, methods=[
'get',
])
request_history_list_view = RequestHistoryList.as_view(
'request_history_list')
bp.add_url_rule('/history/list',
view_func=request_history_list_view,
methods=[
'get',
])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint():
bp = Blueprint('rses', __name__, url_prefix='/rses')
attributes_view = Attributes.as_view('attributes')
bp.add_url_rule('/<rse>/attr/<key>', view_func=attributes_view, methods=['post', 'delete'])
bp.add_url_rule('/<rse>/attr/', view_func=attributes_view, methods=['get', ])
distance_view = Distance.as_view('distance')
bp.add_url_rule('/<source>/distances/<destination>', view_func=distance_view, methods=['get', 'post', 'put'])
protocol_view = Protocol.as_view('protocol')
bp.add_url_rule('/<rse>/protocols/<scheme>/<hostname>/<port>', view_func=protocol_view, methods=['delete', 'put'])
bp.add_url_rule('/<rse>/protocols/<scheme>/<hostname>', view_func=protocol_view, methods=['delete', 'put'])
bp.add_url_rule('/<rse>/protocols/<scheme>', view_func=protocol_view, methods=['get', 'post', 'delete', 'put'])
protocol_list_view = ProtocolList.as_view('protocol_list')
bp.add_url_rule('/<rse>/protocols', view_func=protocol_list_view, methods=['get', ])
lfns2pfns_view = LFNS2PFNS.as_view('lfns2pfns')
bp.add_url_rule('/<rse>/lfns2pfns', view_func=lfns2pfns_view, methods=['get', ])
rse_account_usage_limit_view = RSEAccountUsageLimit.as_view('rse_account_usage_limit')
bp.add_url_rule('/<rse>/accounts/usage', view_func=rse_account_usage_limit_view, methods=['get', ])
usage_view = Usage.as_view('usage')
bp.add_url_rule('/<rse>/usage', view_func=usage_view, methods=['get', 'put'])
usage_history_view = UsageHistory.as_view('usage_history')
bp.add_url_rule('/<rse>/usage/history', view_func=usage_history_view, methods=['get', ])
limits_view = Limits.as_view('limits')
bp.add_url_rule('/<rse>/limits', view_func=limits_view, methods=['get', 'put'])
qos_policy_view = QoSPolicy.as_view('qos_policy')
bp.add_url_rule('/<rse>/qos_policy', view_func=qos_policy_view, methods=['get', ])
bp.add_url_rule('/<rse>/qos_policy/<policy>', view_func=qos_policy_view, methods=['post', 'delete'])
rse_view = RSE.as_view('rse')
bp.add_url_rule('/<rse>', view_func=rse_view, methods=['get', 'delete', 'put', 'post'])
rses_view = RSEs.as_view('rses')
bp.add_url_rule('/', view_func=rses_view, methods=['get', ])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def set_up_admin(app: Flask):
from .roles.helpers import is_admin_view
mod = Blueprint('admin', __name__)
# Дивимось на ролі
mod.before_request(is_admin_view)
# Реєстрація блюпрінта
app.register_blueprint(mod, url_prefix='/admin')
def blueprint():
bp = Blueprint('archives', __name__, url_prefix='/archives')
archive_view = Archive.as_view('archive')
bp.add_url_rule('/<path:scope_name>/files', view_func=archive_view, methods=['get', ])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint():
bp = Blueprint('heartbeats', __name__, url_prefix='/heartbeats')
heartbeat_view = Heartbeat.as_view('heartbeat')
bp.add_url_rule('', view_func=heartbeat_view, methods=['get', 'post'])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def create_blueprint(apiname='api'):
from .main.decorators import before_request, after_request
blueprint = Blueprint(apiname, __name__)
#add decorators to blueprint
blueprint.before_request(before_request)
blueprint.after_app_request(after_request)
return blueprint
def blueprint(no_doc=True):
bp = Blueprint('dirac', __name__, url_prefix='/dirac')
add_file_view = AddFiles.as_view('addfiles')
bp.add_url_rule('/addfiles', view_func=add_file_view, methods=['post', ])
bp.add_url_rule('/addfiles/', view_func=add_file_view, methods=['post', ])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint():
bp = Blueprint('lifetime_exceptions', __name__, url_prefix='/lifetime_exceptions')
lifetime_exception_view = LifetimeException.as_view('lifetime_exception')
bp.add_url_rule('/', view_func=lifetime_exception_view, methods=['get', 'post'])
lifetime_exception_id_view = LifetimeExceptionId.as_view('lifetime_exception_id')
bp.add_url_rule('/<exception_id>', view_func=lifetime_exception_id_view, methods=['get', 'put'])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint():
bp = Blueprint('tmp_dids', __name__, url_prefix='/tmp_dids')
bulk_dids_view = BulkDIDS.as_view('bulk_dids')
bp.add_url_rule('', view_func=bulk_dids_view, methods=[
'post',
])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint(no_doc=True):
bp = Blueprint('import', __name__, url_prefix='/import')
import_view = Import.as_view('scope')
if no_doc:
# rule without trailing slash needs to be added before rule with trailing slash
bp.add_url_rule('', view_func=import_view, methods=['post', ])
bp.add_url_rule('/', view_func=import_view, methods=['post', ])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint():
bp = Blueprint('scope', __name__, url_prefix='/scopes')
scope_view = Scope.as_view('scope')
bp.add_url_rule('/', view_func=scope_view, methods=['get', ])
bp.add_url_rule('/<account>/<scope>', view_func=scope_view, methods=['post', ])
account_scope_list_view = AccountScopeList.as_view('account_scope_list')
bp.add_url_rule('/<account>/scopes', view_func=account_scope_list_view, methods=['get', ])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint(no_doc=True):
bp = Blueprint('replicas', __name__, url_prefix='/replicas')
list_replicas_view = ListReplicas.as_view('list_replicas')
bp.add_url_rule('/list', view_func=list_replicas_view, methods=['post', ])
replicas_view = Replicas.as_view('replicas')
if no_doc:
# rule without trailing slash needs to be added before rule with trailing slash
bp.add_url_rule('', view_func=replicas_view, methods=['post', 'put', 'delete'])
bp.add_url_rule('/', view_func=replicas_view, methods=['post', 'put', 'delete'])
suspicious_replicas_view = SuspiciousReplicas.as_view('suspicious_replicas')
bp.add_url_rule('/suspicious', view_func=suspicious_replicas_view, methods=['get', 'post'])
bad_replicas_states_view = BadReplicasStates.as_view('bad_replicas_states')
bp.add_url_rule('/bad/states', view_func=bad_replicas_states_view, methods=['get', ])
bad_replicas_summary_view = BadReplicasSummary.as_view('bad_replicas_summary')
bp.add_url_rule('/bad/summary', view_func=bad_replicas_summary_view, methods=['get', ])
bad_replicas_pfn_view = BadPFNs.as_view('add_bad_pfns')
bp.add_url_rule('/bad/pfns', view_func=bad_replicas_pfn_view, methods=['post', ])
bad_replicas_dids_view = BadDIDs.as_view('add_bad_dids')
bp.add_url_rule('/bad/dids', view_func=bad_replicas_dids_view, methods=['post', ])
replicas_rse_view = ReplicasRSE.as_view('replicas_rse')
bp.add_url_rule('/rse/<rse>', view_func=replicas_rse_view, methods=['get', ])
bad_replicas_view = BadReplicas.as_view('bad_replicas')
bp.add_url_rule('/bad', view_func=bad_replicas_view, methods=['post', ])
replicas_dids_view = ReplicasDIDs.as_view('replicas_dids')
bp.add_url_rule('/dids', view_func=replicas_dids_view, methods=['post', ])
dataset_replicas_view = DatasetReplicas.as_view('dataset_replicas')
bp.add_url_rule('/<path:scope_name>/datasets', view_func=dataset_replicas_view, methods=['get', ])
dataset_replicas_bulk_view = DatasetReplicasBulk.as_view('dataset_replicas_bulk')
bp.add_url_rule('/datasets_bulk', view_func=dataset_replicas_bulk_view, methods=['post', ])
dataset_replicas_vp_view = DatasetReplicasVP.as_view('dataset_replicas_vp')
bp.add_url_rule('/<path:scope_name>', view_func=replicas_view, methods=['get', ])
set_tombstone_view = Tombstone.as_view('set_tombstone')
bp.add_url_rule('/tombstone', view_func=set_tombstone_view, methods=['post', ])
if no_doc:
bp.add_url_rule('/list/', view_func=list_replicas_view, methods=['post', ])
bp.add_url_rule('/suspicious/', view_func=suspicious_replicas_view, methods=['get', 'post'])
bp.add_url_rule('/bad/states/', view_func=bad_replicas_states_view, methods=['get', ])
bp.add_url_rule('/bad/summary/', view_func=bad_replicas_summary_view, methods=['get', ])
bp.add_url_rule('/bad/pfns/', view_func=bad_replicas_pfn_view, methods=['post', ])
bp.add_url_rule('/bad/dids/', view_func=bad_replicas_dids_view, methods=['post', ])
bp.add_url_rule('/rse/<rse>/', view_func=replicas_rse_view, methods=['get', ])
bp.add_url_rule('/bad/', view_func=bad_replicas_view, methods=['post', ])
bp.add_url_rule('/dids/', view_func=replicas_dids_view, methods=['post', ])
bp.add_url_rule('/datasets_bulk/', view_func=dataset_replicas_bulk_view, methods=['post', ])
bp.add_url_rule('/<path:scope_name>/datasets_vp', view_func=dataset_replicas_vp_view, methods=['get', ])
bp.add_url_rule('/<path:scope_name>/', view_func=replicas_view, methods=['get', ])
bp.add_url_rule('/tombstone/', view_func=set_tombstone_view, methods=['post', ])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint(no_doc=True):
bp = Blueprint('accountlimits', __name__, url_prefix='/accountlimits')
local_account_limit_view = LocalAccountLimit.as_view('local_account_limit')
bp.add_url_rule('/local/<account>/<rse>', view_func=local_account_limit_view, methods=['post', 'delete'])
if no_doc:
bp.add_url_rule('/<account>/<rse>', view_func=local_account_limit_view, methods=['post', 'delete'])
global_account_limit_view = GlobalAccountLimit.as_view('global_account_limit')
bp.add_url_rule('/global/<account>/<rse_expression>', view_func=global_account_limit_view, methods=['post', 'delete'])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def register_routes(app, di_container):
for bp_name, actions in routing.items():
blueprint = Blueprint(name=bp_name, import_name=__name__)
for middleware in actions['middlewares']:
blueprint.before_request(di_container[middleware])
for route in actions['routes']:
blueprint.add_url_rule(route['uri'],
view_func=di_container[route['action']],
methods=route['methods'])
app.register_blueprint(blueprint)
def create_api_bp(name='api_bp'):
api_bp = Blueprint(name, __name__)
api = Api(api_bp, errors=errors)
CORS(api_bp)
api_bp.add_url_rule('/search', view_func=search)
api_bp.add_url_rule('/token', view_func=get_token)
register_errors(api_bp)
register_resources(api)
api_bp.before_request(auth_required)
return api_bp
def blueprint():
bp = Blueprint('vos', __name__, url_prefix='/vos')
recover_view = RecoverVO.as_view('recover')
bp.add_url_rule('/<vo>/recover', view_func=recover_view, methods=['post', ])
vo_view = VO.as_view('vo')
bp.add_url_rule('/<vo>', view_func=vo_view, methods=['put', 'post'])
vos_view = VOs.as_view('vos')
bp.add_url_rule('/', view_func=vos_view, methods=['get', ])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def create_blueprint(cls, app):
"""
Method to create a blueprint, derived from a SilverFlask Controller.
It is one instance per blueprint. TODO: This might be a bad design and
it should probably better be one instance per request.
:param app: current app (in flask initialization)
:return: Blueprint
"""
inst = cls()
endpoint = cls.__name__
url_prefix = cls.url_prefix
static_folder = 'static'
static_url_path = '/static'
if hasattr(cls, 'static_folder'):
static_folder = cls.static_folder
static_url_path = '/static'
print(static_folder)
blueprint = Blueprint(endpoint,
__name__,
url_prefix=url_prefix,
static_folder=static_folder,
static_url_path=static_url_path)
blueprint.jinja_loader = ThemeTemplateLoader()
view_funcs = {}
for url in cls.urls:
action = cls.urls[url]
kwargs = {'methods': ['GET']}
if action in cls.allowed_actions:
kwargs['methods'] += ['POST']
blueprint.add_url_rule(url, cls.urls[url],
getattr(inst, cls.urls[url]), **kwargs)
if hasattr(cls, 'before_request'):
blueprint.before_request(getattr(inst, 'before_request'))
template_functions = {}
for fun in cls.template_functions:
template_functions[fun] = getattr(inst,
inst.template_functions[fun])
blueprint.context_processor(lambda: template_functions)
for m in cls.mro():
if hasattr(m, 'init_blueprint'):
m.init_blueprint(blueprint)
return blueprint
def blueprint():
bp = Blueprint('rules', __name__, url_prefix='/rules')
rule_view = Rule.as_view('rule')
bp.add_url_rule('/<rule_id>',
view_func=rule_view,
methods=['get', 'put', 'delete'])
all_rule_view = AllRule.as_view('all_rule')
bp.add_url_rule('/', view_func=all_rule_view, methods=['get', 'post'])
replica_locks_view = ReplicaLocks.as_view('replica_locks')
bp.add_url_rule('/<rule_id>/locks',
view_func=replica_locks_view,
methods=[
'get',
])
reduce_rule_view = ReduceRule.as_view('reduce_rule')
bp.add_url_rule('/<rule_id>/reduce',
view_func=reduce_rule_view,
methods=[
'post',
])
move_rule_view = MoveRule.as_view('move_rule')
bp.add_url_rule('/<rule_id>/move',
view_func=move_rule_view,
methods=[
'post',
])
rule_history_view = RuleHistory.as_view('rule_history')
bp.add_url_rule('/<rule_id>/history',
view_func=rule_history_view,
methods=[
'get',
])
rule_history_full_view = RuleHistoryFull.as_view('rule_history_full')
bp.add_url_rule('/<path:scope_name>/history',
view_func=rule_history_full_view,
methods=[
'get',
])
rule_analysis_view = RuleAnalysis.as_view('rule_analysis')
bp.add_url_rule('/<rule_id>/analysis',
view_func=rule_analysis_view,
methods=[
'get',
])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def _factory(bp_name, url_prefix, restricted=False):
import_name = 'project.{}.views'.format(bp_name)
template_folder = 'templates'
blueprint = Blueprint(
bp_name,
import_name,
template_folder=template_folder,
url_prefix=url_prefix,
)
if restricted:
blueprint.before_request(_only_authenticated_user_hook)
return blueprint
def register_api(app):
blueprint = Blueprint(name='api',
import_name=__name__,
url_prefix="/api/v1")
api = Api(
app=blueprint,
version='1.0',
title='New Api',
)
api.add_namespace(auth_wx_ns, path="/")
api.add_namespace(message_wx_ns, path="/callback")
blueprint.before_request(test)
app.register_blueprint(blueprint)
def _factory(
partial_module_string: str, url_prefix: str, protected: bool = False
) -> Blueprint:
# Create the blueprint
blueprint = Blueprint(
partial_module_string,
f"src.blueprint.{partial_module_string}",
url_prefix=url_prefix,
)
# This endpoint is not to be publicly used,
# protect the endpoint with an authorization routine
if protected:
blueprint.before_request(authorize_blueprint)
return blueprint
def blueprint():
bp = Blueprint('config', __name__, url_prefix='/config')
option_set_view = OptionSet.as_view('option_set')
bp.add_url_rule('/<section>/<option>/<value>', view_func=option_set_view, methods=['put', ])
option_get_del_view = OptionGetDel.as_view('option_get_del')
bp.add_url_rule('/<section>/<option>', view_func=option_get_del_view, methods=['get', 'delete'])
section_view = Section.as_view('section')
bp.add_url_rule('/<section>', view_func=section_view, methods=['get', ])
config_view = Config.as_view('config')
bp.add_url_rule('', view_func=config_view, methods=['get', 'post'])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint():
bp = Blueprint('subscriptions', __name__, url_prefix='/subscriptions')
subscription_id_view = SubscriptionId.as_view('subscription_id')
bp.add_url_rule('/Id/<subscription_id>',
view_func=subscription_id_view,
methods=[
'get',
])
states_view = States.as_view('states')
bp.add_url_rule('/<account>/<name>/Rules/States',
view_func=states_view,
methods=[
'get',
])
bp.add_url_rule('/<account>/Rules/States',
view_func=states_view,
methods=[
'get',
])
rules_view = Rules.as_view('rules')
bp.add_url_rule('/<account>/<name>/Rules',
view_func=rules_view,
methods=[
'get',
])
subscription_view = Subscription.as_view('subscription')
bp.add_url_rule('/<account>/<name>',
view_func=subscription_view,
methods=['get', 'post', 'put'])
bp.add_url_rule('/<account>',
view_func=subscription_view,
methods=[
'get',
])
bp.add_url_rule('/', view_func=subscription_view, methods=[
'get',
])
subscription_name_view = SubscriptionName.as_view('subscription_name')
bp.add_url_rule('/Name/<name>',
view_func=subscription_name_view,
methods=[
'get',
])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def blueprint():
bp = Blueprint('dids', __name__, url_prefix='/dids')
scope_view = Scope.as_view('scope')
bp.add_url_rule('/<scope>/', view_func=scope_view, methods=['get', ])
guid_lookup_view = GUIDLookup.as_view('guid_lookup')
bp.add_url_rule('/<guid>/guid', view_func=guid_lookup_view, methods=['get', ])
search_view = Search.as_view('search')
bp.add_url_rule('/<scope>/dids/search', view_func=search_view, methods=['get', ])
search_extended_view = SearchExtended.as_view('search_extended')
bp.add_url_rule('/<scope>/dids/search_extended', view_func=search_extended_view, methods=['get', ])
dids_view = DIDs.as_view('dids')
bp.add_url_rule('/<path:scope_name>/status', view_func=dids_view, methods=['put', ])
files_view = Files.as_view('files')
bp.add_url_rule('/<path:scope_name>/files', view_func=files_view, methods=['get', ])
attachment_history_view = AttachmentHistory.as_view('attachment_history')
bp.add_url_rule('/<path:scope_name>/dids/history', view_func=attachment_history_view, methods=['get', ])
attachment_view = Attachment.as_view('attachment')
bp.add_url_rule('/<path:scope_name>/dids', view_func=attachment_view, methods=['get', 'post', 'delete'])
meta_view = Meta.as_view('meta')
bp.add_url_rule('/<path:scope_name>/meta', view_func=meta_view, methods=['get', 'post', 'delete'])
singlemeta_view = SingleMeta.as_view('singlemeta')
bp.add_url_rule('/<path:scope_name>/meta/<key>', view_func=singlemeta_view, methods=['post', ])
rules_view = Rules.as_view('rules')
bp.add_url_rule('/<path:scope_name>/rules', view_func=rules_view, methods=['get', ])
parents_view = Parents.as_view('parents')
bp.add_url_rule('/<path:scope_name>/parents', view_func=parents_view, methods=['get', ])
associated_rules_view = AssociatedRules.as_view('associated_rules')
bp.add_url_rule('/<path:scope_name>/associated_rules', view_func=associated_rules_view, methods=['get', ])
follow_view = Follow.as_view('follow')
bp.add_url_rule('/<path:scope_name>/follow', view_func=follow_view, methods=['get', 'post', 'delete'])
bp.add_url_rule('/<path:scope_name>', view_func=dids_view, methods=['get', 'post'])
bulkdids_view = BulkDIDS.as_view('bulkdids')
bp.add_url_rule('', view_func=bulkdids_view, methods=['post', ])
sample_view = Sample.as_view('sample')
bp.add_url_rule('/<input_scope>/<input_name>/<output_scope>/<output_name>/<nbfiles>/sample', view_func=sample_view, methods=['post', ])
attachements_view = Attachments.as_view('attachments')
bp.add_url_rule('/attachments', view_func=attachements_view, methods=['post', ])
new_dids_view = NewDIDs.as_view('new_dids')
bp.add_url_rule('/new', view_func=new_dids_view, methods=['get', ])
resurrect_view = Resurrect.as_view('resurrect')
bp.add_url_rule('/resurrect', view_func=resurrect_view, methods=['post', ])
bulkmeta_view = BulkMeta.as_view('bulkmeta')
bp.add_url_rule('/bulkmeta', view_func=bulkmeta_view, methods=['post', ])
bp.before_request(request_auth_env)
bp.after_request(response_headers)
return bp
def Blueprint(name, **kwargs):
from flask import Blueprint
from werkzeug.exceptions import default_exceptions
from cloudapp.authentication.decorators import load_user
error_if_exists = kwargs.pop('subdomain', None)
if error_if_exists:
raise RuntimeError("[cloudapp_api] Blueprint: subdomain is not an allowed keyword")
bp = Blueprint(name, __name__, subdomain="api", **kwargs)
bp.before_request(load_user)
bp.before_request(_process_request_json)
for code in default_exceptions.iterkeys():
if code >= 500: continue
@bp.errorhandler(code)
def errorhandler(code):
return _json_errorhandler(code)
return bp
def create_blueprint(cls, app):
"""
Method to create a blueprint, derived from a SilverFlask Controller.
It is one instance per blueprint. TODO: This might be a bad design and
it should probably better be one instance per request.
:param app: current app (in flask initialization)
:return: Blueprint
"""
inst = cls()
endpoint = cls.__name__
url_prefix = cls.url_prefix
static_folder = "static"
static_url_path = "/static"
if hasattr(cls, "static_folder"):
static_folder = cls.static_folder
static_url_path = "/static"
print(static_folder)
blueprint = Blueprint(
endpoint, __name__, url_prefix=url_prefix, static_folder=static_folder, static_url_path=static_url_path
)
blueprint.jinja_loader = ThemeTemplateLoader()
view_funcs = {}
for url in cls.urls:
action = cls.urls[url]
kwargs = {"methods": ["GET"]}
if action in cls.allowed_actions:
kwargs["methods"] += ["POST"]
blueprint.add_url_rule(url, cls.urls[url], getattr(inst, cls.urls[url]), **kwargs)
if hasattr(cls, "before_request"):
blueprint.before_request(getattr(inst, "before_request"))
template_functions = {}
for fun in cls.template_functions:
template_functions[fun] = getattr(inst, inst.template_functions[fun])
blueprint.context_processor(lambda: template_functions)
for m in cls.mro():
if hasattr(m, "init_blueprint"):
m.init_blueprint(blueprint)
return blueprint
def check_forced_registration_blueprint(name, import_name, **kwargs):
ignore_patterns = kwargs.pop('ignore_patterns', [])
bp = Blueprint(name, import_name, **kwargs)
def match_any_ignore_pattern():
for methods, path in ignore_patterns:
if request.method in methods and path.match(request.path):
return True
return False
def check_impl():
if not g.user or match_any_ignore_pattern():
return
if g.user.has_not_registered_schedule_yet():
return redirect(url_for('schedule.schedule'))
bp.before_request(check_impl)
return bp
def blueprint(
name,
import_name,
objects,
setup=setup_tree,
path=path,
methods=['get', 'post', 'put', 'patch', 'delete', 'head'],
super_root_class=TreeRootView,
**kwargs
):
bp = Blueprint(name, import_name)
bp.before_request(partial(setup_tree, objects, super_root_class,
**kwargs))
if hasattr(super_root_class, 'view'):
bp.route('/', methods=methods)(path)
bp.route('/<path:path>', methods=methods)(path)
return bp
from flask import Blueprint
from app.main.authentication.auth import requires_auth
AUTHORIZATION_HEADER = "Authorization"
AUTHORIZATION_SCHEME = "Bearer"
WINDOW = 1
main = Blueprint("main", __name__)
main.before_request(requires_auth)
from app.main.views import notifications, index
from app.main import errors
from flask import Blueprint
delivery_ws = Blueprint("delivery_ws", __name__, static_folder="static",
template_folder="templates")
from litefac.apis.auth import load_user_from_token
delivery_ws.before_request(load_user_from_token)
from litefac.portal.delivery_ws import webservices
from . import printer as api_printer
from . import job as api_job
from . import connection as api_connection
from . import files as api_files
from . import settings as api_settings
from . import timelapse as api_timelapse
from . import users as api_users
from . import log as api_logs
from . import slicing as api_slicing
from . import printer_profiles as api_printer_profiles
from . import languages as api_languages
VERSION = "0.1"
api.before_request(apiKeyRequestHandler)
api.after_request(corsResponseHandler)
#~~ data from plugins
@api.route("/plugin/<string:name>", methods=["GET"])
def pluginData(name):
api_plugins = octoprint.plugin.plugin_manager().get_filtered_implementations(lambda p: p._identifier == name, octoprint.plugin.SimpleApiPlugin)
if not api_plugins:
return make_response("Not found", 404)
if len(api_plugins) > 1:
return make_response("More than one api provider registered for {name}, can't proceed".format(name=name), 500)
api_plugin = api_plugins[0]
if api_plugin.is_api_adminonly() and not current_user.is_admin():
from gbi_server.lib.helper import send_mail
from gbi_server.lib.couchdb import init_user_boxes
from gbi_server.lib.external_wms import write_mapproxy_config
admin = Blueprint("admin", __name__, template_folder="../templates")
def assert_admin_user():
if current_app.config.get('ADMIN_PARTY'):
return
if current_user.is_anonymous():
raise Unauthorized()
if not current_user.is_admin:
raise Forbidden()
admin.before_request(assert_admin_user)
@admin.route('/admin')
def index():
return render_template('admin/index.html')
@admin.route('/admin/user_list', methods=["GET"])
def user_list():
return render_template('admin/user_list.html', users=User.query.all())
@admin.route('/admin/user_detail/<int:id>', methods=["GET", "POST"])
def user_detail(id):
user = User.by_id(id)
return render_template('admin/user_detail.html', user=user)
@admin.route('/admin/verify_user/<int:id>', methods=["GET"])
# return redirect('/')
form = FriendForm()
if request.method == 'GET':
return render_template('template_friends.html',form=form, isLogged=True)
else:
if form.validate_on_submit():
temp = Friends(form.name.data,form.address.data,form.age.data,session['user_id'])
#Save the image if present
if form.upload_file.data:
filename = secure_filename(form.upload_file.data.filename)
form.upload_file.data.save('app/static/images' + form.upload_file.data.filename)
temp.filename ='/static/images/' + filename
db.session.add(temp)
db.session.commit()
#tapa 2
user = Users.query.get(session['user_id'])
print(user.friends)
return render_template('template_user.html',isLogged=True,friends=user.friends)
else:
flash('At least one field is empty')
return render_template('template_friends.html',isLogged=True,form=form)
def before_request():
if not 'isLogged' in session:
return redirect('/')
ud.before_request(before_request) #tehään ennen routeen siirtymistä
from flask import g
from flask import make_response
from flask import request
from flask import session
from flask import redirect
from flask import url_for
from pinserver.helpers import before_request
from pinserver.models.user import User
from pinserver.models.pin import Pin
from pinserver.models.comment import Comment
comment = Blueprint('comment', __name__)
comment.before_request(before_request)
# support functions
def comments_pack(comments):
comment_list = []
for comment in comments:
comment_item = {}
comment_item['comment_id'] = str(comment.id)
comment_item['content'] = comment.content
comment_item['author_id'] = str(comment.author.id)
comment_item['author_name'] = comment.author.nickname
comment_item['avatar'] = comment.author.avatar
comment_item['create_at'] = comment.create_at.strftime('%Y-%m-%d %H:%M:%S')
comment_list.append(comment_item)
res_data = {
'total':len(comment_list),
from flask import Blueprint
order_ws = Blueprint("order_ws", __name__, static_folder="static",
template_folder="templates")
from lite_mms.apis.auth import load_user_from_token
order_ws.before_request(load_user_from_token)
from lite_mms.portal.order_ws import webservices
form = FriendForm()
if request.method == 'GET':
return render_template('template_friends.html',form=form,isLogged=True)
else:
if form.validate_on_submit():
print('friends from submit ok')
temp = Friends(form.name.data,form.address.data,form.age.data,session['user_id'])
# save the image if present
if form.upload_file.data:
filename = secure_filename(form.upload_file.data.filename)
form.upload_file.data.save('app/static/images/' + filename)
temp.filename = '/static/images/' + filename
db.session.add(temp)
db.session.commit()
#2. tapa listata ystävät. Kts db_models.py
user = Users.query.get(session['user_id'])
print(user.friends)
return render_template('template_user.html',isLogged=True,friends=user.friends)
else:
flash('Give proper values to all fields')
return render_template('template_friends.html',form=form,isLogged=True)
def before_request():
if not 'isLogged' in session:
return redirect('/')
#tämä suoritetaan aina ennen minkään route:n suorittamista
ud.before_request(before_request)
from flask import Blueprint, render_template, g, request, current_app
from flask_login import login_required
from ..models import UserNotice
from ..g_func import user_and_session
from ..util.async_task import mark_notice_read
from .. import db
notice = Blueprint('notice', __name__, template_folder='../templates/notice')
notice.before_request(user_and_session)
@notice.route('/')
def index():
page = request.args.get('page', 1, type=int)
# need pip install https://github.com/mitsuhiko/flask-sqlalchemy/pull/328
# n_paginate = db.session.query(UserNotice).\
# filter_by(to_uid=g.user.id).\
# paginate(page, current_app.config.get(
# 'NOTICES_PER_PAGE', 30))
n_paginate = g.user.r_notices.paginate(page, current_app.config.get(
'NOTICES_PER_PAGE', 30))
notices = n_paginate.items
mark_notice_read.delay(g.user.id)
return render_template('notices.html', paginate=n_paginate, notices=notices)
class Admin(object):
"""Class that provides a way to add admin interface to Flask applications.
:param app: The Flask application
:param url_prefix: The url prefix
:param main_dashboard: The main dashboard object
:param endpoint: The endpoint
"""
def __init__(self, app, url_prefix="/admin", title="flask-dashed",
main_dashboard=None, endpoint='admin'):
if not main_dashboard:
from dashboard import DefaultDashboard
main_dashboard = DefaultDashboard
self.blueprint = Blueprint(endpoint, __name__,
static_folder='static', template_folder='templates')
self.app = app
self.url_prefix = url_prefix
self.endpoint = endpoint
self.title = title
self.secure_functions = OrderedMultiDict()
# Checks security for current path
self.blueprint.before_request(
lambda: self.check_path_security(request.path))
self.app.register_blueprint(self.blueprint, url_prefix=url_prefix)
self.root_nodes = []
self._add_node(main_dashboard, '/', 'main-dashboard', 'dashboard')
# Registers recursive_getattr filter
self.app.jinja_env.filters['recursive_getattr'] = recursive_getattr
def register_node(self, url_prefix, endpoint, short_title, title=None,
parent=None, node_class=AdminNode):
"""Registers admin node.
:param url_prefix: The url prefix
:param endpoint: The endpoint
:param short_title: The short title
:param title: The long title
:param parent: The parent node path
:param node_class: The class for node objects
"""
return self._add_node(node_class, url_prefix, endpoint, short_title,
title=title, parent=parent)
def register_module(self, module_class, url_prefix, endpoint, short_title,
title=None, parent=None):
"""Registers new module to current admin.
"""
return self._add_node(module_class, url_prefix, endpoint, short_title,
title=title, parent=parent)
def _add_node(self, node_class, url_prefix, endpoint, short_title,
title=None, parent=None):
"""Registers new node object to current admin object.
"""
title = short_title if not title else title
if parent and not issubclass(parent.__class__, AdminNode):
raise Exception('`parent` class must be AdminNode subclass')
new_node = node_class(self, url_prefix, endpoint, short_title,
title=title, parent=parent)
if parent:
parent.children.append(new_node)
else:
self.root_nodes.append(new_node)
return new_node
@property
def main_dashboard(self):
return self.root_nodes[0]
def add_path_security(self, path, function, http_code=403):
"""Registers security function for given path.
:param path: The endpoint to secure
:param function: The security function
:param http_code: The response http code
"""
self.secure_functions.add(path, (function, http_code))
def check_path_security(self, path):
"""Checks security for specific and path.
:param path: The path to check
"""
for key in self.secure_functions.iterkeys():
if path.startswith("%s%s" % (self.url_prefix, key)):
for function, http_code in self.secure_functions.getlist(key):
if not function():
return abort(http_code)
def create_blueprint():
gitpages_web_ui = Blueprint(
'gitpages_web_ui',
__name__,
template_folder='templates',
)
gitpages_web_ui.add_url_rule(
'/',
'index_view',
index_view_default_ref,
defaults={
'page_number': 1,
},
)
gitpages_web_ui.add_url_rule(
'/index/page/<int:page_number>/',
'index_view',
index_view_default_ref,
)
gitpages_web_ui.add_url_rule(
'/feed/atom',
'atom_feed',
atom_feed,
)
gitpages_web_ui.add_url_rule(
'/feed/rss',
'rss_feed_redirect',
rss_feed_redirect,
)
gitpages_web_ui.add_url_rule(
'/' + '/'.join(
[
'archives',
'<git_ref:tree_id>',
'<int(fixed_digits=4):year>',
'<int(fixed_digits=2):month>',
'<int(fixed_digits=2):day>',
'<slug>',
]
) + '/',
'page_archive_view_ref',
page_archive_view,
)
gitpages_web_ui.add_url_rule(
'/' + '/'.join(
[
'archives',
'<int(fixed_digits=4):year>',
'<int(fixed_digits=2):month>',
'<int(fixed_digits=2):day>',
'<slug>',
]
) + '/',
'page_archive_view',
page_archive_view_default_ref,
)
gitpages_web_ui.add_url_rule(
'/' + '/'.join(
[
'archives',
'<int(fixed_digits=4):year>',
'<int(fixed_digits=2):month>',
'<int(fixed_digits=2):day>',
]
) + '/',
'daily_archive',
daily_archive_default,
defaults={
'page_number': 1,
},
)
gitpages_web_ui.add_url_rule(
'/' + '/'.join(
[
'archives',
'<int(fixed_digits=4):year>',
'<int(fixed_digits=2):month>',
]
) + '/',
'monthly_archive',
monthly_archive_default,
defaults={
'page_number': 1,
},
)
gitpages_web_ui.add_url_rule(
'/' + '/'.join(
[
'archives',
'<int(fixed_digits=4):year>',
]
) + '/',
'yearly_archive',
yearly_archive_default,
defaults={
'page_number': 1,
},
)
gitpages_web_ui.add_url_rule(
'/' + '/'.join(
[
'attachment',
'<git_ref:tree_id>',
]
),
'attachment',
attachment,
defaults=dict(
inline=False,
),
)
gitpages_web_ui.add_url_rule(
'/' + '/'.join(
[
'attachment',
'<git_ref:tree_id>',
'inline',
]
),
'inline_attachment',
attachment,
defaults=dict(
inline=True,
),
)
gitpages_web_ui.before_app_first_request(setup_gitpages_application)
gitpages_web_ui.before_request(setup_gitpages)
gitpages_web_ui.teardown_request(teardown_gitpages)
return gitpages_web_ui
abort(401)
if not token_is_valid(incoming_token):
abort(403, incoming_token)
def token_is_valid(incoming_token):
if Token.query.filter(Token.token == incoming_token).first():
return True
return False
def get_token_from_headers(headers):
auth_header = headers.get('Authorization', '')
if auth_header[:7] != 'Bearer ':
return None
return auth_header[7:]
main.before_request(check_url_scheme)
main.before_request(requires_authentication)
@main.after_request
def add_cache_control(response):
response.cache_control.max_age = 24 * 60 * 60
return response
from .views import notification, organisation, job, service, user, index
from . import errors, encryption
session, redirect, url_for,
abort, flash)
from ..models import Session, ModelError
from ..models.user import User, UserOperator
from .helpers import (save_account_to_session,
check_consistency, get_next_url,
render_template, login_and_sid_matching_required)
from .oauth import providers, BaseOAuthError, BaseOAuth
account_bp = Blueprint('account', __name__)
user_op = UserOperator(Session())
account_bp.before_request(check_consistency)
@account_bp.route('/')
def profile():
next_url = get_next_url()
if g.is_login:
session.pop('provider', None)
session.pop('token', None)
if g.is_login or ('token' in session and 'provider' in session):
return render_template('account/profile.html', next=next_url)
else:
return redirect(url_for('session.render_login'))
@account_bp.route('/delete', methods=['POST'])
from . import files as api_files
from . import settings as api_settings
from . import timelapse as api_timelapse
from . import users as api_users
from . import log as api_logs
from . import slicing as api_slicing
from . import printer_profiles as api_printer_profiles
from . import languages as api_languages
from . import system as api_system
VERSION = "0.1"
api.after_request(noCachingExceptGetResponseHandler)
api.before_request(corsRequestHandler)
api.before_request(enforceApiKeyRequestHandler)
api.before_request(loginFromApiKeyRequestHandler)
api.after_request(corsResponseHandler)
#~~ data from plugins
@api.route("/plugin/<string:name>", methods=["GET"])
def pluginData(name):
api_plugins = octoprint.plugin.plugin_manager().get_filtered_implementations(lambda p: p._identifier == name, octoprint.plugin.SimpleApiPlugin)
if not api_plugins:
return make_response("Not found", 404)
if len(api_plugins) > 1:
return make_response("More than one api provider registered for {name}, can't proceed".format(name=name), 500)
def flaskbb_load_blueprints(app):
forum = Blueprint("forum", __name__)
register_view(
forum,
routes=[
"/category/<int:category_id>", "/category/<int:category_id>-<slug>"
],
view_func=ViewCategory.as_view("view_category")
)
register_view(
forum,
routes=[
"/forum/<int:forum_id>/edit", "/forum/<int:forum_id>-<slug>/edit"
],
view_func=ManageForum.as_view("manage_forum")
)
register_view(
forum,
routes=["/forum/<int:forum_id>", "/forum/<int:forum_id>-<slug>"],
view_func=ViewForum.as_view("view_forum")
)
register_view(
forum,
routes=["/<int:forum_id>/markread", "/<int:forum_id>-<slug>/markread"],
view_func=MarkRead.as_view("markread")
)
register_view(
forum,
routes=[
"/<int:forum_id>/topic/new", "/<int:forum_id>-<slug>/topic/new"
],
view_func=NewTopic.as_view("new_topic")
)
register_view(
forum,
routes=["/memberlist"],
view_func=MemberList.as_view("memberlist")
)
register_view(
forum,
routes=["/post/<int:post_id>/delete"],
view_func=DeletePost.as_view("delete_post")
)
register_view(
forum,
routes=["/post/<int:post_id>/edit"],
view_func=EditPost.as_view("edit_post")
)
register_view(
forum,
routes=["/post/<int:post_id>/raw"],
view_func=RawPost.as_view("raw_post")
)
register_view(
forum,
routes=["/post/<int:post_id>/report"],
view_func=ReportView.as_view("report_post")
)
register_view(
forum,
routes=["/post/<int:post_id>"],
view_func=ViewPost.as_view("view_post")
)
register_view(
forum,
routes=["/search"],
view_func=Search.as_view("search")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/delete",
"/topic/<int:topic_id>-<slug>/delete"
],
view_func=DeleteTopic.as_view("delete_topic")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/highlight",
"/topic/<int:topic_id>-<slug>/highlight"
],
view_func=HighlightTopic.as_view("highlight_topic")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/lock", "/topic/<int:topic_id>-<slug>/lock"
],
view_func=LockTopic.as_view("lock_topic")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/post/<int:post_id>/reply",
"/topic/<int:topic_id>-<slug>/post/<int:post_id>/reply"
],
view_func=NewPost.as_view("reply_post")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/post/new",
"/topic/<int:topic_id>-<slug>/post/new"
],
view_func=NewPost.as_view("new_post")
)
register_view(
forum,
routes=["/topic/<int:topic_id>", "/topic/<int:topic_id>-<slug>"],
view_func=ViewTopic.as_view("view_topic")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/trivialize",
"/topic/<int:topic_id>-<slug>/trivialize"
],
view_func=TrivializeTopic.as_view("trivialize_topic")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/unlock",
"/topic/<int:topic_id>-<slug>/unlock"
],
view_func=UnlockTopic.as_view("unlock_topic")
)
register_view(
forum,
routes=[
"/topictracker/<int:topic_id>/add",
"/topictracker/<int:topic_id>-<slug>/add"
],
view_func=TrackTopic.as_view("track_topic")
)
register_view(
forum,
routes=[
"/topictracker/<int:topic_id>/delete",
"/topictracker/<int:topic_id>-<slug>/delete"
],
view_func=UntrackTopic.as_view("untrack_topic")
)
register_view(
forum,
routes=["/topictracker"],
view_func=TopicTracker.as_view("topictracker")
)
register_view(forum, routes=["/"], view_func=ForumIndex.as_view("index"))
register_view(
forum,
routes=["/who-is-online"],
view_func=WhoIsOnline.as_view("who_is_online")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/hide", "/topic/<int:topic_id>-<slug>/hide"
],
view_func=HideTopic.as_view("hide_topic")
)
register_view(
forum,
routes=[
"/topic/<int:topic_id>/unhide",
"/topic/<int:topic_id>-<slug>/unhide"
],
view_func=UnhideTopic.as_view("unhide_topic")
)
register_view(
forum,
routes=["/post/<int:post_id>/hide"],
view_func=HidePost.as_view("hide_post")
)
register_view(
forum,
routes=["/post/<int:post_id>/unhide"],
view_func=UnhidePost.as_view("unhide_post")
)
register_view(
forum,
routes=[
"/markdown",
"/markdown/<path:mode>"
],
view_func=MarkdownPreview.as_view("markdown_preview")
)
forum.before_request(force_login_if_needed)
app.register_blueprint(forum, url_prefix=app.config["FORUM_URL_PREFIX"])
from flask import Blueprint
from ..authentication import requires_authentication
main = Blueprint('main', __name__)
main.before_request(requires_authentication)
@main.after_request
def add_cache_control(response):
response.cache_control.max_age = 24 * 60 * 60
return response
from .views import suppliers, services, users, drafts
from . import errors
from . import connection as api_connection
from . import files as api_files
from . import settings as api_settings
from . import timelapse as api_timelapse
from . import users as api_users
from . import slicing as api_slicing
from . import printer_profiles as api_printer_profiles
from . import languages as api_languages
from . import system as api_system
VERSION = "0.1"
api.after_request(noCachingExceptGetResponseHandler)
api.before_request(corsRequestHandler)
api.before_request(loginFromAuthorizationHeaderRequestHandler)
api.before_request(loginFromApiKeyRequestHandler)
api.after_request(corsResponseHandler)
#~~ data from plugins
@api.route("/plugin/<string:name>", methods=["GET"])
def pluginData(name):
api_plugins = octoprint.plugin.plugin_manager().get_filtered_implementations(lambda p: p._identifier == name, octoprint.plugin.SimpleApiPlugin)
if not api_plugins:
return make_response("Not found", 404)
if len(api_plugins) > 1:
return make_response("More than one api provider registered for {name}, can't proceed".format(name=name), 500)
from copy import deepcopy
from bson import ObjectId
import datetime
from flask import Blueprint, current_app, render_template, request, make_response, jsonify, g
from flask.views import MethodView
from ..utils import get_payload, send_response, str_to_date, serialize, Validator, get_docs
from ..login import check_valid_auth
# for CRUD operations see http://stackoverflow.com/a/630475/1607448
# TODO check for special forbidden operators see: http://docs.mongodb.org/manual/reference/limits/
mod = Blueprint('accounting', __name__, url_prefix='/api/accounting')
# secure the whole blueprint
mod.before_request(check_valid_auth)
buchungs_schema = {
'date':{'type':'datetime','required':True},
'client':{'type':'string','required':True,'empty':False},
'tags':{'type':'list'},
'account':{'type':'string','required':True,'empty':False},
'info':{'type':'string'},
'amount':{'type':'float','required':True,'forbidden':[0.0]},
'category':{'type':'string','required':False},
'comment':{'type':'string'},
'_edit_time':{'type':'datetime','required':False},
'_edit_by':{'type':'string','required':False},
'_id':{'type':'objectid','required':False},
}
buchungs_validator = Validator(buchungs_schema)
def serialize_for_search(payload):
for key in ('date','_edit_time'):
from flask import Blueprint
manufacture_ws = Blueprint("manufacture_ws", __name__, static_folder="static",
template_folder="templates")
from litefac.apis.auth import load_user_from_token
manufacture_ws.before_request(load_user_from_token)
from litefac.portal.manufacture_ws import webservices
url_for,
jsonify,
render_template
)
from validate_email import validate_email
from time import time
SESSION_LIFETIME_S = 259200 # 3 days
ui = Blueprint('ui', __name__)
def make_session_permanent():
session.permanent = True
current_app.permanent_session_lifetime = SESSION_LIFETIME_S
ui.before_request(make_session_permanent)
def current_user():
if 'uid' not in session or session['expiry'] < time():
return None
return User.query.filter_by(id=session['uid']).first()
def require_user():
if 'uid' not in session or session['expiry'] < time():
abort(401)
return User.query.filter_by(id=session['uid']).first_or_404()
##############
# HTML Pages #
##############
@ui.route('/', methods=['GET'])
from flask import Blueprint
from ..authentication import requires_authentication
auth = Blueprint('auth', __name__)
auth.before_request(requires_authentication)
from . import views # noqa
from flask import Blueprint
cargo_ws = Blueprint("cargo_ws", __name__, static_folder="static",
template_folder="templates")
from litefac.apis.auth import load_user_from_token
cargo_ws.before_request(load_user_from_token)
from litefac.portal.cargo_ws import webservices
"""
import ujson as json
from datetime import datetime
from flask import Blueprint
from flask import g
from pinserver.helpers import before_request
from pinserver.models.user import User
from pinserver.models.pin import Pin
from pinserver.models.fav import Fav
fav = Blueprint('fav', __name__)
fav.before_request(before_request)
@fav.route('/fav/<pin_id>')
def fav_pin(pin_id):
if g.user_id:
already_fav = Fav.objects(owner=g.user_id, pin=pin_id).first()
if not already_fav:
pin = Pin.objects(id=pin_id).first()
user = User.objects(id=g.user_id).first()
fav = Fav(owner=user,
pin=pin,
create_at=datetime.utcnow())
fav.save()
return ('fav success', 200)
return ('already fav', 400)
return ('fav pin session timeout', 400)
# -*- coding: utf-8 -*-
from flask import Blueprint, g, session, redirect, flash
from ..models import Session
from ..models.user import UserOperator
from .helpers import check_consistency, login_and_sid_matching_required, render_template, get_next_url
session_bp = Blueprint("session", __name__)
user_op = UserOperator(Session())
session_bp.before_request(check_consistency)
@session_bp.route("/login")
def render_login():
next_url = get_next_url()
if g.is_login:
return redirect(next_url)
else:
return render_template("session/login.html", next=next_url)
@session_bp.route("/logout", methods=["GET", "POST"])
@login_and_sid_matching_required
def logout():
session.clear()
flash("You have been logout", category="success")
return redirect(get_next_url())
