def decorated_endpoint(*args, **kwargs):
args = list(args)
if len(args) == 0:
current_app.logger.warning("Request missing id.")
return required_info_missing(["id"])
if len(args) > 1:
return (
dict(
status="UNEXPECTED_PARAMS",
message="Only expected one parameter (id).",
),
400,
)
try:
id = int(args[0])
except ValueError:
current_app.logger.warning(
"Cannot parse ID argument from request.")
return required_info_missing(["id"],
"Cannot parse ID arg as int.")
user: UserModel = UserModel.query.filter_by(
id=int(id)).one_or_none()
if user is None:
raise abort(404, f"User {id} not found")
if not current_user.has_role("admin"):
if admins_only or user != current_user:
return unauthorized_handler(None, [])
args = (user, )
return fn(*args, **kwargs)
def decorated_service(*args, **kwargs):
form = get_form_from_request(request)
if form is None:
current_app.logger.warning(
"Unsupported request method for inferring resolution from request."
)
return invalid_method(request.method)
if not all(
key in kwargs
for key in [
"value_groups",
"start",
"duration",
]
):
current_app.logger.warning("Could not infer resolution.")
fields = ("values", "start", "duration")
return required_info_missing(fields, "Resolution cannot be inferred.")
if "generic_asset_name_groups" not in kwargs:
return required_info_missing(
(entity_type),
"Required resolution cannot be found without asset info.",
)
# Calculating (inferring) the resolution in the POSTed data
inferred_resolution = (
(kwargs["start"] + kwargs["duration"]) - kwargs["start"]
) / len(kwargs["value_groups"][0])
# Finding the required resolution for assets affected in this request
required_resolution = None
last_asset = None
for asset_group in kwargs["generic_asset_name_groups"]:
for asset_descriptor in asset_group:
# Getting the asset
generic_asset = get_generic_asset(asset_descriptor, entity_type)
if generic_asset is None:
return unrecognized_asset(
f"Failed to look up asset by {asset_descriptor}"
)
# Complain if assets don't all require the same resolution
if (
required_resolution is not None
and generic_asset.event_resolution != required_resolution
):
return conflicting_resolutions(
f"Cannot send data for both {generic_asset} and {last_asset}."
)
# Setting the resolution & remembering last looked-at asset
required_resolution = generic_asset.event_resolution
last_asset = generic_asset
# if inferred resolution is a multiple from required_solution, we can upsample_values
if inferred_resolution % required_resolution == timedelta(hours=0):
for i in range(len(kwargs["value_groups"])):
kwargs["value_groups"][i] = upsample_values(
kwargs["value_groups"][i],
from_resolution=inferred_resolution,
to_resolution=required_resolution,
)
inferred_resolution = required_resolution
if inferred_resolution != required_resolution:
current_app.logger.warning(
f"Resolution {inferred_resolution} is not accepted. We require {required_resolution}."
)
return unapplicable_resolution(
isodate.duration_isoformat(required_resolution)
)
else:
kwargs["resolution"] = inferred_resolution
return fn(*args, **kwargs)