class Match(HTTPEndpoint):
@use_args(
{
"players": fields.Dict(required=True),
"maps": fields.Dict(required=True),
"team_names": fields.Dict(required=True),
}, )
async def post(self, request, args):
""" Creates match. """
return responder.render(await
request.state.league.match().create(**args))
@use_args({
"match_id": fields.String(required=True),
})
async def delete(self, request, args):
""" Deletes match. """
return responder.render(await request.state.league.match(**args).end())
@use_args({
"match_id": fields.String(required=True),
})
async def get(self, request, args):
""" Gets base details of match. """
return responder.render(await request.state.league.match(**args).get())
class FilterSchema(Schema):
query = fields.Dict(missing=dict)
view = fields.Nested(ViewSchema, missing=dict)
schema = fields.String(missing='__schema__')
class Meta:
strict = True
class Prediction(Resource):
@use_args({
"dataset":
fields.Str(required=True),
"query":
fields.Dict(keys=fields.Str, values=fields.Float, required=True)
})
def post(self, args):
try:
dataset_meta = DatasetMeta.objects.raw({"_id": args["dataset"]})
target_meta = dataset_meta.first().as_dict()
if strip_neural_meta(target_meta["keys"]) != set(
args["query"].keys()):
return {"error": "wrong keys for the specified dataset"}, 422
if args["dataset"] != classifier.dataset:
data = get_dataset(args["dataset"])
logging.info(
"Starting the training session with dataset {}".format(
args["dataset"]))
classifier.train(args["dataset"], list(target_meta["keys"]),
data)
stripped_keys = list(strip_neural_meta(target_meta["keys"]))
ordered_query = to_ordered_list(stripped_keys, args["query"])
return {"situation": int(classifier.predict(ordered_query))}, 200
except DoesNotExist:
return {"error": "no such dataset"}, 404
class RHSignURL(RH):
"""Create a persistent signed URL for a user.
This build a url and adds a signature that authenticates the user without
requiring them to have session cookies. It is meant for cases where the
user actively requests a persistent link to use outside their browser,
e.g. for a calendar feed.
When called without authentication, no token is added, so it just behaves
as the normal ``url_for`` in order to allow client-side code to be more
straightforward and always call this API regardless of whether the user is
authenticated or not.
"""
@use_kwargs({
'endpoint': fields.String(required=True,
validate=validate_with_message(lambda ep: ep in current_app.view_functions,
'Invalid endpoint')),
'params': fields.Dict(keys=fields.String(), load_default={},
validate=validate_with_message(lambda params: not any(x.startswith('_') for x in params),
'Params starting with an underscore are not allowed'))
})
def _process(self, endpoint, params):
try:
if session.user:
url = signed_url_for_user(session.user, endpoint, _external=True, **params)
Logger.get('url_signing').info("%s signed URL for endpoint '%s' with params %r", session.user, endpoint,
params)
else:
url = url_for(endpoint, _external=True, **params)
except BuildError as exc:
# if building fails for a valid endpoint we can be pretty sure that it's due to
# some required params missing
abort(422, messages={'params': [str(exc)]})
return jsonify(url=url)
class FunctionResource(Resource):
#UNCOMMENT FOR REQUIRED AUTHENTICATION
#method_decorators = [jwt_required]
base_directory = "neuroapi.api.neuro."
query_args = {
'function': fields.Str(required=True),
'params': fields.Dict(required=True)
}
@use_args(query_args)
def post(self, args):
return self.call_function(args["function"], args["params"])
@use_args(query_args)
def get(self, args):
return self.call_function(args["function"], args["params"])
def call_function(self, function, params):
function_call = "neurocore." + function
func = eval(function_call)
try:
ret = func(**params)
except Exception as e:
return {"error": str(e)}, 400
return {"result": ret}, 200
class RHWebhook(RH):
CSRF_ENABLED = False
def _check_access(self):
token = request.headers.get('Authorization')
expected_token = current_plugin.settings.get('webhook_token')
if not expected_token or not token or token != expected_token:
raise Forbidden
@use_kwargs({
'event': fields.String(required=True),
'payload': fields.Dict(required=True)
}, unknown=EXCLUDE)
def _process(self, event, payload):
meeting_id = payload['object']['id']
vc_room = VCRoom.query.filter(VCRoom.data.contains({'zoom_id': meeting_id})).first()
if not vc_room:
# This usually happens when a room wasn't created via indico
current_plugin.logger.debug('Action for unhandled Zoom room: %s', meeting_id)
return
if event in ('meeting.updated', 'webinar.updated'):
current_plugin.refresh_room(vc_room, None)
elif event in ('meeting.deleted', 'webinar.deleted'):
current_plugin.logger.info('Zoom room deleted: %s', meeting_id)
vc_room.status = VCRoomStatus.deleted
else:
current_plugin.logger.warning('Unhandled Zoom webhook payload: %s', event)
class MaskSchema(Schema): id = fields.Int(required=True) name = fields.Str(required=True) description = fields.Str(required=True) genome_build = fields.Str(required=True) group_type = fields.Str(required=True) identifier_type = fields.Str(required=True) groups = fields.Dict(keys=fields.Str(), values=fields.List(VariantField))
class Task2Schema(Task2ListSchema, ma.SQLAlchemyAutoSchema):
calculation = fields.Nested(CalculationListSchema)
infiles = fields.Nested(ArtifactSchema, many=True)
outfiles = fields.Nested(ArtifactSchema, many=True)
data = fields.Dict()
class Meta:
model = Task2
class EventEndpointsSchema(Schema):
tags = fields.Nested(ListEndpointSchema)
editable_types = fields.String(required=True)
file_types = fields.Dict(
keys=fields.String(),
values=fields.Nested(ListEndpointSchema),
required=True,
)
class PowerPlantLoadSchema(Schema):
load = fields.Float(validate=lambda load: load >= 0)
fuels = fields.Dict(fields.String(
validate=lambda fuel_name: fuel_name in
["gas(euro/MWh)", "kerosine(euro/MWh)", "co2(euro/ton)", "wind(%)"]),
fields.Float(),
required=True,
validate=validate.Length(min=1))
powerplants = fields.List(fields.Nested(PowerPlantSchema),
required=True,
validate=validate.Length(min=1))
class ConfigFile(Resource):
configRequest = {'config': fields.Dict(required=True)}
def get(self):
dataConfigFile = ConfigHelper.getDataFromConfigFile()
return {"config": dataConfigFile}
@use_args(configRequest)
def put(self, request):
messageResult = ConfigHelper.putDataToConfigFile(request['config'])
return {"message": messageResult}
class RHCreateRoomBlocking(RHRoomBookingBase):
@use_args({
'room_ids': fields.List(fields.Int(), missing=[]),
'start_date': fields.Date(),
'end_date': fields.Date(),
'reason': fields.Str(),
'allowed_principals': fields.List(fields.Dict())
})
def _process(self, args):
blocking = create_blocking(created_by=session.user, **args)
return jsonify(blockings_schema.dump(blocking, many=False).data)
class RHCreateRoomBlocking(RHRoomBookingBase):
@use_args({
'room_ids': fields.List(fields.Int(), missing=[]),
'start_date': fields.Date(),
'end_date': fields.Date(),
'reason': fields.Str(),
'allowed_principals': fields.List(fields.Dict())
})
def _process(self, args):
blocking = create_blocking(created_by=session.user, **args)
approve_or_request_blocking(blocking)
return jsonify_data(flash=False)
class EventEndpointsSchema(Schema):
tags = fields.Nested({
"create": fields.String(required=True),
"list": fields.String(required=True)
})
editable_types = fields.String(required=True)
file_types = fields.Dict(
keys=fields.String(),
values=fields.Nested({
"create": fields.String(required=True),
"list": fields.String(required=True),
}),
required=True,
)
class AllocationsTarget(MethodResource):
@jwt_required
@use_kwargs(post_args, locations=('json', 'form'))
@use_kwargs_doc(post_args, locations=('json', 'form'))
@doc(tags=['Cube'],
description='Retrieves target asset allocations for Cube.')
def post(self, cube_id):
# email = get_jwt_identity()
cube = Cube.query.get(cube_id)
# is_owner(cube, email)
if cube:
try:
# Target asset allocations
allocations = asset_allocations(cube)
if not allocations:
balances, total = get_balance_data([cube], cube.user)
allocations = asset_allocations_from_balances(balances)
return {'allocations_target': allocations}
except:
return {}
else:
return {}
ext_args = {
**post_args,
**{
'new_allocations':
fields.List(
fields.Dict(required=True, description='New allocations')),
}
}
@jwt_required
@use_kwargs(ext_args, locations=('json', 'form'))
@use_kwargs_doc(ext_args, locations=('json', 'form'))
@doc(tags=['Cube'],
description='Updates target asset allocations for Cube.')
def put(self, cube_id, new_allocations):
# email = get_jwt_identity()
cube = Cube.query.get(cube_id)
# is_owner(cube, email)
if cube:
# New target asset allocations
return asset_allocations_set(cube, new_allocations)
else:
message = 'No cube associated with ID {}'.format(cube_id)
abort(404, message=message)
class CalculationSchema(CalculationListSchema):
id = fields.UUID()
collection = fields.Str(attribute='collection.name')
code = fields.Str(attribute='code.name')
structure = fields.Nested('StructureSchema',
only=(
'id',
'name',
'_links',
))
test = fields.Str(attribute='test.name')
tasks = fields.Nested('Task2ListSchema', many=True)
testresults = fields.Nested('TestResultSchema',
many=True,
exclude=('calculations', ))
metadata = fields.Dict(attribute='mdata')
_links = ma.Hyperlinks({
'self':
ma.AbsoluteURLFor('calculationresource', cid='<id>'),
'preview':
ma.AbsoluteURLFor('calculationpreviewresource', cid='<id>'),
'collection':
ma.AbsoluteURLFor('calculationlistresource'),
'tasks':
ma.AbsoluteURLFor('calculationtask2listresource', cid='<id>'),
})
basis_sets = fields.Nested(CalculationBasisSetAssociationSchema,
attribute='basis_set_associations',
many=True)
pseudos = fields.Nested(PseudopotentialSchema,
many=True,
exclude=(
'pseudo',
'converted_from',
))
class Meta:
model = Calculation
exclude = (
'basis_set_associations',
'tasks_query',
'testresults_query',
'mdata',
)
class ArtifactSchema(ma.SQLAlchemyAutoSchema):
_links = ma.Hyperlinks({
'self':
ma.AbsoluteURLFor('artifactresource', aid='<id>'),
'collection':
ma.AbsoluteURLFor('artifactlistresource'),
'download':
ma.AbsoluteURLFor('artifactdownloadresource', aid='<id>'),
'view':
ma.AbsoluteURLFor('artifactviewresource', aid='<id>'),
})
metadata = fields.Dict(attribute='mdata')
class Meta:
model = Artifact
fields = ('id', 'name', '_links', 'metadata')
class Dataset(Resource):
def get(self, name):
try:
dataset_meta = DatasetMeta.objects.raw({"_id": name})
target_meta = dataset_meta.first().as_dict()
return target_meta, 200
except DoesNotExist:
return {"error": "no such dataset"}, 404
@use_args({
"situation":
fields.Integer(required=True),
"entry":
fields.Dict(keys=fields.Str, values=fields.Float, required=True)
})
def post(self, args, name):
try:
dataset_meta = DatasetMeta.objects.raw({"_id": name})
target_meta = dataset_meta.first().as_dict()
if strip_neural_meta(target_meta["keys"]) != set(
args["entry"].keys()):
# The keys passed as input via the dataset API are different from the ones
# used in the dataset.
return {"error": "wrong keys for the specified dataset"}, 422
# Decorate the incoming data with information about the situation and the time
now = datetime.datetime.now()
args["entry"]["situation"] = args["situation"]
args["entry"]["hour"] = now.hour
args["entry"]["minute"] = now.minute
DatasetEntry(dataset=name,
entry=to_ordered_list(target_meta["keys"],
args["entry"])).save()
return {"dataset": name, "entry": args["entry"]}, 200
except DoesNotExist:
return {"error": "no such dataset"}, 404
def delete(self, name):
try:
dataset_meta = DatasetMeta.objects.raw({"_id": name})
deleted_meta = dataset_meta.first().as_dict()
dataset_meta.delete()
return deleted_meta, 200
except DoesNotExist:
return {"error": "no such dataset"}, 404
class RHUpdateRoomBlocking(RHRoomBookingBase):
def _check_access(self):
RHRoomBookingBase._check_access(self)
if not self.blocking.can_edit(session.user):
raise Forbidden
def _process_args(self):
self.blocking = Blocking.get_one(request.view_args['blocking_id'])
@use_args({
'room_ids': fields.List(fields.Int(), required=True),
'reason': fields.Str(required=True),
'allowed_principals': fields.List(fields.Dict(), missing=[])
})
def _process(self, args):
update_blocking(self.blocking, **args)
return jsonify(blockings_schema.dump(self.blocking, many=False).data)
class TestResultSchema(ma.SQLAlchemyAutoSchema):
_links = ma.Hyperlinks({
'collection':
ma.AbsoluteURLFor('testresultlistresource'),
'self':
ma.AbsoluteURLFor('testresultresource', trid='<id>'),
})
test = fields.Str(attribute='test.name')
calculations = fields.Nested(CalculationListSchema, many=True)
collections = fields.Nested('TestResultCollectionSchema',
exclude=('testresults', ),
many=True)
metadata = fields.Dict(attribute='mdata')
class Meta:
model = TestResult2
exclude = ('mdata', )
class RHProgramCodesAPIContributions(RHManageEventBase):
"""RESTful API to bulk-update contribution codes."""
def _process_GET(self):
return jsonify(
{c.friendly_id: c.code
for c in self.event.contributions})
@use_kwargs({
'codes':
fields.Dict(keys=fields.Int, values=fields.String, required=True)
})
def _process_PATCH(self, codes):
contribs = {
c.friendly_id: c
for c in Contribution.query.with_parent(self.event).filter(
Contribution.friendly_id.in_(codes))
}
if invalid := (codes - contribs.keys()):
abort(422,
messages={
'codes':
[f'Invalid IDs: {", ".join(map(str, invalid))}']
})
updates = {}
for friendly_id, code in codes.items():
contrib = contribs[friendly_id]
if code != contrib.code:
updates[contrib] = (contrib.code, code)
contrib.code = code
self.event.log(EventLogRealm.management,
LogKind.change,
'Program',
'Program codes assigned to contributions',
session.user,
data=_get_update_log_data(updates))
return jsonify({
contrib.friendly_id: changes
for contrib, changes in updates.items()
})
class RHCreateRoomBlocking(RHRoomBookingBase):
@use_kwargs({
'room_ids': fields.List(fields.Int(), missing=[]),
'start_date': fields.Date(),
'end_date': fields.Date(),
'reason': fields.Str(),
'allowed_principals': fields.List(fields.Dict(), missing=[])
})
def _process(self, room_ids, start_date, end_date, reason,
allowed_principals):
rooms = Room.query.filter(Room.id.in_(room_ids)).all()
allowed = []
for obj in allowed_principals:
if obj.get('is_group'):
allowed.append(GroupProxy(obj['id'], provider=obj['provider']))
else:
allowed.append(User.query.filter(User.id == obj['id']).one())
blocking = create_blocking(rooms, start_date, end_date, reason,
allowed)
approve_or_request_blocking(blocking)
return jsonify_data(flash=False)
def add_file_routes(app, is_local, server_path):
""" Create routes related to file submission for flask app """
# Keys for the post route will correspond to the four types of files
@app.route("/v1/upload_dabs_files/", methods=["POST"])
@requires_agency_perms('writer')
def upload_dabs_files():
if "multipart/form-data" not in request.headers['Content-Type']:
return JsonResponse.error(
ValueError("Request must be a multipart/form-data type"),
StatusCode.CLIENT_ERROR)
file_manager = FileHandler(request,
is_local=is_local,
server_path=server_path)
return file_manager.validate_upload_dabs_files()
@app.route("/v1/check_status/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
@use_kwargs({'type': webargs_fields.String(missing='')})
def check_status(submission, type):
return get_status(submission, type)
@app.route("/v1/submission_metadata/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
def submission_metadata(submission):
return JsonResponse.create(StatusCode.OK,
get_submission_metadata(submission))
@app.route("/v1/submission_data/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
@use_kwargs({'type': webargs_fields.String(missing='')})
def submission_data(submission, type):
return get_submission_data(submission, type)
@app.route("/v1/revalidation_threshold/", methods=["GET"])
@requires_login
def revalidation_threshold():
return JsonResponse.create(StatusCode.OK, get_revalidation_threshold())
@app.route("/v1/window/", methods=["GET"])
def window():
return list_windows()
@app.route("/v1/error_metrics/", methods=["POST"])
@convert_to_submission_id
@requires_submission_perms('reader')
def submission_error_metrics(submission):
return get_error_metrics(submission)
@app.route("/v1/list_submissions/", methods=["POST"])
@requires_login
@use_kwargs({
'page':
webargs_fields.Int(missing=1),
'limit':
webargs_fields.Int(missing=5),
'certified':
webargs_fields.String(required=True,
validate=webargs_validate.OneOf(
('mixed', 'true', 'false'))),
'sort':
webargs_fields.String(missing='modified'),
'order':
webargs_fields.String(missing='desc'),
'd2_submission':
webargs_fields.Bool(missing=False),
'filters':
webargs_fields.Dict(keys=webargs_fields.String(), missing={})
})
def list_submissions(page, limit, certified, sort, order, d2_submission,
filters):
""" List submission IDs associated with the current user """
return list_submissions_handler(page, limit, certified, sort, order,
d2_submission, filters)
@app.route("/v1/list_certifications/", methods=["POST"])
@convert_to_submission_id
@requires_submission_perms('reader')
def submission_list_certifications(submission):
""" List all certifications for a specific submission """
return list_certifications(submission)
@app.route("/v1/get_certified_file/", methods=["POST"])
@use_kwargs({
'submission_id': webargs_fields.Int(required=True),
'certified_files_history_id': webargs_fields.Int(required=True),
'is_warning': webargs_fields.Bool(missing=False)
})
@requires_submission_perms('reader')
def get_certified_file(submission, certified_files_history_id, is_warning):
""" Get the signed URL for the specified file history """
return file_history_url(submission, certified_files_history_id,
is_warning, is_local)
@app.route("/v1/get_protected_files/", methods=["GET"])
@requires_login
def get_protected_files():
""" Return signed URLs for all help page files """
file_manager = FileHandler(request,
is_local=is_local,
server_path=server_path)
return file_manager.get_protected_files()
@app.route("/v1/check_current_page/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
def check_current_page(submission):
return check_current_submission_page(submission)
@app.route("/v1/get_fabs_meta/", methods=["POST"])
@convert_to_submission_id
@requires_submission_perms('reader')
def get_fabs_metadata(submission):
""" Return metadata of FABS submission """
return JsonResponse.create(StatusCode.OK,
get_fabs_meta(submission.submission_id))
@app.route("/v1/upload_fabs_file/", methods=["POST"])
@requires_sub_agency_perms('editfabs')
def upload_fabs_file():
if "multipart/form-data" not in request.headers['Content-Type']:
return JsonResponse.error(
ValueError("Request must be a multipart/form-data type"),
StatusCode.CLIENT_ERROR)
params = RequestDictionary.derive(request)
fabs = params.get('_files', {}).get('fabs', None)
file_manager = FileHandler(request,
is_local=is_local,
server_path=server_path)
return file_manager.upload_fabs_file(fabs)
@app.route("/v1/submit_detached_file/", methods=["POST"])
@convert_to_submission_id
@requires_submission_perms('fabs', check_owner=False)
def submit_detached_file(submission):
file_manager = FileHandler(request,
is_local=is_local,
server_path=server_path)
return file_manager.publish_fabs_submission(submission)
@app.route("/v1/get_obligations/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
def get_obligations(submission):
return JsonResponse.create(
StatusCode.OK, get_submission_stats(submission.submission_id))
@app.route("/v1/submission/<int:submission_id>/narrative", methods=['GET'])
@requires_submission_perms('reader')
def get_submission_narratives(submission):
return narratives_for_submission(submission)
@app.route("/v1/submission/<int:submission_id>/narrative",
methods=['POST'])
@requires_submission_perms('writer')
def post_submission_narratives(submission):
return update_narratives(submission, request.json)
@app.route("/v1/submission/<int:submission_id>/report_url",
methods=['GET'])
@requires_submission_perms('reader')
@use_kwargs({
'warning':
webargs_fields.Bool(),
'file_type':
webargs_fields.String(required=True,
validate=webargs_validate.OneOf(
FILE_TYPE_DICT.keys() -
{'executive_compensation', 'sub_award'})),
'cross_type':
webargs_fields.String(validate=webargs_validate.OneOf([
'program_activity', 'award_financial', 'award_procurement', 'award'
]))
})
def post_submission_report_url(submission, warning, file_type, cross_type):
return submission_report_url(submission, bool(warning), file_type,
cross_type)
@app.route("/v1/get_file_url", methods=['GET'])
@convert_to_submission_id
@requires_submission_perms('reader')
@use_kwargs({
'file_type':
webargs_fields.String(required=True,
validate=webargs_validate.OneOf(
FILE_TYPE_DICT_LETTER.values()))
})
def get_file_url(submission, file_type):
return get_upload_file_url(submission, file_type)
@app.route("/v1/delete_submission/", methods=['POST'])
@convert_to_submission_id
@requires_submission_perms('writer', check_fabs='editfabs')
def delete_submission(submission):
""" Deletes all data associated with the specified submission
NOTE: THERE IS NO WAY TO UNDO THIS
"""
return delete_all_submission_data(submission)
@app.route("/v1/check_year_quarter/", methods=["GET"])
@requires_login
@use_kwargs({
'cgac_code': webargs_fields.String(),
'frec_code': webargs_fields.String(),
'reporting_fiscal_year': webargs_fields.String(required=True),
'reporting_fiscal_period': webargs_fields.String(required=True)
})
def check_year_and_quarter(cgac_code, frec_code, reporting_fiscal_year,
reporting_fiscal_period):
""" Check if cgac (or frec) code, year, and quarter already has a published submission """
return find_existing_submissions_in_period(cgac_code, frec_code,
reporting_fiscal_year,
reporting_fiscal_period)
@app.route("/v1/certify_submission/", methods=['POST'])
@convert_to_submission_id
@requires_submission_perms('submitter', check_owner=False)
def certify_submission(submission):
file_manager = FileHandler(request,
is_local=is_local,
server_path=server_path)
return certify_dabs_submission(submission, file_manager)
@app.route("/v1/restart_validation/", methods=['POST'])
@convert_to_submission_id
@requires_submission_perms('writer', check_fabs='editfabs')
@use_kwargs({'d2_submission': webargs_fields.Bool(missing=False)})
def restart_validation(submission, d2_submission):
return FileHandler.restart_validation(submission, d2_submission)
return result
@blueprint.route("/", methods=("GET", ))
@permission_taxonomy_read_all.require(http_exception=403)
def taxonomy_list():
"""List all available taxonomies."""
return jsonify([
jsonify_taxonomy(t) for t in current_flask_taxonomies.taxonomy_list()
])
@blueprint.route("/", methods=("POST", ))
@use_kwargs({
"code": fields.Str(required=True),
"extra_data": fields.Dict(location='extra_data')
})
@permission_taxonomy_create_all.require(http_exception=403)
def taxonomy_create(code: str, extra_data: dict = None):
"""Create a new Taxonomy."""
try:
created = current_flask_taxonomies.create_taxonomy(
code=code, extra_data=extra_data)
created_dict = jsonify_taxonomy(created)
response = jsonify(created_dict)
response.status_code = 201
response.headers['Location'] = created_dict['links']['self']
return response
except IntegrityError:
raise BadRequest("Taxonomy with this code already exists.")
class UpdateSchema(Schema):
query = fields.Dict(required=True)
data = fields.Dict(required=True)
class Meta:
strict = True
def add_dashboard_routes(app):
""" Create routes related to agency data dashboard for flask app """
@app.route('/v1/get_rule_labels/', methods=['POST'])
@use_kwargs({
'files': webargs_fields.List(webargs_fields.String(), required=True),
'fabs': webargs_fields.Bool(missing=False),
'error_level': webargs_fields.String(validate=webargs_validate.
OneOf(['warning', 'error', 'mixed'],
error='Must be either warning, error, or mixed'),
missing='warning')
})
def get_rule_labels(**kwargs):
""" Returns the rule labels based on the filters provided """
files = kwargs.get('files')
fabs = kwargs.get('fabs')
error_level = kwargs.get('error_level')
return list_rule_labels(files, error_level, fabs)
@app.route("/v1/historic_dabs_graphs/", methods=["POST"])
@requires_login
@use_kwargs({
'filters': webargs_fields.Dict(keys=webargs_fields.String(), missing={})
})
def historic_dabs_graphs(**kwargs):
""" Returns the historic DABS graphs based on the filters provided """
filters = kwargs.get('filters')
return historic_dabs_warning_graphs(filters)
@app.route("/v1/historic_dabs_table/", methods=["POST"])
@requires_login
@use_kwargs({
'page': webargs_fields.Int(missing=1),
'limit': webargs_fields.Int(missing=5),
'sort': webargs_fields.String(missing='period'),
'order': webargs_fields.String(missing='desc'),
'filters': webargs_fields.Dict(keys=webargs_fields.String(), required=True)
})
def historic_dabs_table(**kwargs):
""" List warning metadata for selected """
page = kwargs.get('page')
limit = kwargs.get('limit')
sort = kwargs.get('sort')
order = kwargs.get('order')
filters = kwargs.get('filters')
return historic_dabs_warning_table(filters, page, limit, sort, order)
@app.route("/v1/active_submission_overview/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
@use_kwargs({
'file': webargs_fields.String(validate=webargs_validate.
OneOf(['A', 'B', 'C', 'cross-AB', 'cross-BC', 'cross-CD1', 'cross-CD2'],
error='Must be A, B, C, cross-AB, cross-BC, cross-CD1, or cross-CD2'),
required=True),
'error_level': webargs_fields.String(validate=webargs_validate.
OneOf(['warning', 'error', 'mixed'],
error='Must be either warning, error, or mixed'),
missing='warning')
})
def get_active_submission_overview(submission, file, **kwargs):
""" Returns an overview of the requested submission for the active dashboard """
error_level = kwargs.get('error_level')
return active_submission_overview(submission, file, error_level)
@app.route("/v1/get_impact_counts/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
@use_kwargs({
'file': webargs_fields.String(validate=webargs_validate.
OneOf(['A', 'B', 'C', 'cross-AB', 'cross-BC', 'cross-CD1', 'cross-CD2'],
error='Must be A, B, C, cross-AB, cross-BC, cross-CD1, or cross-CD2'),
required=True),
'error_level': webargs_fields.String(validate=webargs_validate.
OneOf(['warning', 'error', 'mixed'],
error='Must be either warning, error, or mixed'),
missing='warning')
})
def impact_counts(submission, file, **kwargs):
""" Returns the impact counts of the requested submission for the active dashboard """
error_level = kwargs.get('error_level')
return get_impact_counts(submission, file, error_level)
@app.route("/v1/get_significance_counts/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
@use_kwargs({
'file': webargs_fields.String(validate=webargs_validate.
OneOf(['A', 'B', 'C', 'cross-AB', 'cross-BC', 'cross-CD1', 'cross-CD2'],
error='Must be A, B, C, cross-AB, cross-BC, cross-CD1, or cross-CD2'),
required=True),
'error_level': webargs_fields.String(validate=webargs_validate.
OneOf(['warning', 'error', 'mixed'],
error='Must be either warning, error, or mixed'),
missing='warning')
})
def significance_counts(submission, file, **kwargs):
""" Returns the significance counts of the requested submission for the active dashboard """
error_level = kwargs.get('error_level')
return get_significance_counts(submission, file, error_level)
@app.route("/v1/active_submission_table/", methods=["GET"])
@convert_to_submission_id
@requires_submission_perms('reader')
@use_kwargs({
'file': webargs_fields.String(validate=webargs_validate.
OneOf(FILE_TYPES,
error='Must be one of the following: {}'.format(', '.join(FILE_TYPES))),
required=True),
'error_level': webargs_fields.String(validate=webargs_validate.
OneOf(['warning', 'error', 'mixed'],
error='Must be either warning, error, or mixed'),
missing='warning'),
'page': webargs_fields.Int(missing=1),
'limit': webargs_fields.Int(missing=5),
'sort': webargs_fields.String(missing='significance'),
'order': webargs_fields.String(missing='asc')
})
def get_active_submission_table(submission, file, **kwargs):
""" Returns an overview of the requested submission for the active dashboard """
error_level = kwargs.get('error_level')
page = kwargs.get('page')
limit = kwargs.get('limit')
sort = kwargs.get('sort')
order = kwargs.get('order')
return active_submission_table(submission, file, error_level, page, limit, sort, order)
from liblio.helpers import flake_id, printable_id
from . import API_PATH
BLUEPRINT_PATH="{api}/settings".format(api=API_PATH)
blueprint = Blueprint('settings', __name__, url_prefix=BLUEPRINT_PATH)
### Request schemas
request_schemas = {
'edit_profile': {
'name': fields.Str(),
'bio': fields.Str(),
'tags': fields.List(fields.Str()),
'private': fields.Boolean(missing=False),
'settings': fields.Dict()
}
}
### Routes
@blueprint.route('/my-profile', methods=('GET',))
@jwt_required
def get_my_profile():
"""Get the profile for the logged-in user. (This may have sensitive/private info.)"""
username = get_jwt_identity()
origin = current_app.config['SERVER_ORIGIN']
profile = User.query.filter_by(username=username, origin=origin).first()
if profile is None:
blueprint = Blueprint("inspirehep_curation", __name__, url_prefix="/curation")
parser = FlaskParser()
@parser.error_handler
def handle_error(error, req, schema, error_status_code, error_headers):
message = f"Incorrect input type for fields: {''.join(error.field_names)}"
abort(400, message)
@blueprint.route("/literature/<int:pid_value>/keywords", methods=["PUT"])
@login_required_with_roles([Roles.cataloger.value])
@parser.use_args(
{
"_desy_bookkeeping": fields.Dict(required=False),
"keywords": fields.List(fields.String, required=False),
"energy_ranges": fields.List(fields.String, required=False),
},
locations=("json",),
)
def add_keywords(args, pid_value):
keywords = args.get("keywords")
desy_bookkeeping = args.get("_desy_bookkeeping")
energy_ranges = args.get("energy_ranges")
if not any([keywords, desy_bookkeeping, energy_ranges]):
return (
jsonify(
success=False,
message="None of required fields was passed",
),
@app.route("/orders/<int:order_id>", methods=["GET"])
@marshal_with(OrderSchema())
def route_order_get_by_id(order_id):
order = Order.query.filter(Order.id == order_id).first()
if not order:
return abort(400,
"The order with id: {0} does not exists".format(order_id))
return order
@app.route("/orders", methods=["POST"])
@marshal_with(OrderSchema())
@use_kwargs({
"buyer_id": fields.Int(),
"seller_id": fields.Int(),
"line_items": fields.List(fields.Dict()),
})
def route_order_create(buyer_id, seller_id, line_items):
order = Order(buyer_id=buyer_id, seller_id=seller_id, line_items=[])
total = 0
for li in line_items:
product = Product.query.filter(Product.id == li['product_id']).first()
total += li['quantity'] * product.price
item = LineItem(product=product,
order=order,
quantity=li['quantity'],
unit_price=li['quantity'] * product.price)
order.line_items.append(item)
order.total = total
db.session.add(order)
db.session.commit()
class WorkflowsRecordSourcesResource(MethodView):
view_name = "workflows_record_sources"
decorators = [
login_required_with_roles(
[Roles.superuser.value, Roles.cataloger.value])
]
@parser.error_handler
def handle_error(error, req, schema, error_status_code, error_headers):
message = f"Incorrect input for fields: {''.join(error.field_names)}"
abort(400, message)
@parser.use_args({
"record_uuid": fields.String(required=True),
"source": fields.String()
})
def get(self, args):
record_uuid = args["record_uuid"]
required_fields_mapping = {
"created": WorkflowsRecordSources.created,
"json": WorkflowsRecordSources.json,
"record_uuid": WorkflowsRecordSources.record_uuid,
"source": WorkflowsRecordSources.source,
"updated": WorkflowsRecordSources.updated,
}
query = WorkflowsRecordSources.query.with_entities(
*required_fields_mapping.values()).filter_by(
record_uuid=str(record_uuid))
source = args.get("source")
if source:
query = query.filter_by(source=source.lower())
results = query.all()
if not results:
return jsonify({"message": "Workflow source not found"}), 404
results_data = [{
key: val
for key, val in zip(required_fields_mapping.keys(), result)
} for result in results]
return jsonify({"workflow_sources": results_data}), 200
@parser.use_args({
"record_uuid": fields.String(required=True),
"source": fields.String(required=True),
"json": fields.Dict(required=True),
})
def post(self, args):
record_uuid = args["record_uuid"]
source = args["source"]
root_json = args["json"]
root = WorkflowsRecordSources(source=source,
record_uuid=record_uuid,
json=root_json)
db.session.merge(root)
db.session.commit()
if root:
return (
jsonify({
"message":
f"workflow source for record {record_uuid} and source {source} added"
}),
200,
)
@parser.use_args({
"record_uuid": fields.String(required=True),
"source": fields.String(required=True),
})
def delete(self, args):
record_uuid = args.get("record_uuid")
source = args.get("source")
result = WorkflowsRecordSources.query.filter_by(
record_uuid=str(record_uuid), source=source.lower()).one_or_none()
if not result:
return (
jsonify({
"message":
"No record found for given record_uuid and source!"
}),
404,
)
db.session.delete(result)
db.session.commit()
return jsonify({"message": "Record succesfully deleted"}), 200
