def _paginate(self, request, collection):
"""Method to paginate through collection result lists.
Use this to return only a slice of a collection, specified in
the request itself. The request should use query parameters
`count` and `page` to specify the slice they want. The slice
will start at index ``(page - 1) * count`` and end (exclusive)
at ``(page * count)``.
"""
# Allow falcon's HTTPBadRequest exceptions to percolate up. They'll
# get turned into HTTP 400 errors.
count = request.get_param_as_int('count')
page = request.get_param_as_int('page')
total_size = len(collection)
if count is None and page is None:
return 0, total_size, collection
# TODO(maxking): Count and page should be positive integers. Once
# falcon 2.0.0 is out and we can jump to it, we can remove this logic
# and use `min_value` parameter in request.get_param_as_int.
if count < 0:
raise falcon.HTTPInvalidParam(
count, 'count should be a positive integer.')
if page < 1:
raise falcon.HTTPInvalidParam(
page, 'page should be greater than 0.')
list_start = (page - 1) * count
list_end = page * count
return list_start, total_size, collection[list_start:list_end]
def before_get_it2(req, resp, name, id):
if len(name) < 6:
raise falcon.HTTPInvalidParam('invalid param',
name + ':' + 'name less than 6')
if int(id) < 10:
raise falcon.HTTPInvalidParam('invalid param',
name + ':' + 'id less than 10')
def on_get(self, req, resp):
"""Handles GET requests"""
if 'min' not in req.params:
raise falcon.HTTPMissingParam('min')
if 'max' not in req.params:
raise falcon.HTTPMissingParam('max')
min_n = req.params['min']
max_n = req.params['max']
if min_n.isnumeric() == False:
raise falcon.HTTPInvalidParam('min must be number', min_n)
if max_n.isnumeric() == False:
raise falcon.HTTPInvalidParam('max must be number', max_n)
min_n = int(min_n)
max_n = int(max_n)
if min_n > max_n:
raise falcon.HTTPInvalidParam('min is bigger than max',
(min_n, max_n))
number = random.randint(min_n, max_n)
result = {'lowerLimit': min_n, 'higherLimit': max_n, 'number': number}
resp.media = result
def parse_request(request, attr):
""" returns mongo compatible query object, based on the query params provided """
if 'lastN' in request.params.keys():
try:
limit_val = int(request.params['lastN'])
except ValueError as e:
raise falcon.HTTPInvalidParam('Must be integer.', 'lastN')
elif 'hLimit' in request.params.keys():
try:
limit_val = int(request.params['hLimit'])
except ValueError as e:
raise falcon.HTTPInvalidParam('Must be integer.', 'hLimit')
else:
raise falcon.HTTPMissingParam('lastN')
query = {'attr': attr, 'value': {'$ne': ' '}}
ts_filter = {}
if 'dateFrom' in request.params.keys():
ts_filter['$gte'] = dateutil.parser.parse(
request.params['dateFrom'])
if 'dateTo' in request.params.keys():
ts_filter['$lte'] = dateutil.parser.parse(request.params['dateTo'])
if len(ts_filter.keys()) > 0:
query['ts'] = ts_filter
ls_filter = {"_id": False, '@timestamp': False, '@version': False}
sort = [('ts', pymongo.DESCENDING)]
return {
'query': query,
'limit': limit_val,
'filter': ls_filter,
'sort': sort
}
def __init__(self, server_state):
"""
Initialization method
Args:
server_state (bool): True if server is under maintance.
Raises:
falcon.HTTPInvalidParam
Returns:
None
"""
if server_state is None:
raise falcon.HTTPInvalidParam(
title="Invalid Param",
description="Server State should be passed.")
if type(server_state) is not bool:
raise falcon.HTTPInvalidParam(
title="Invalid Param",
description=
"Invalid datatype. Server Maintaince manager accepts bool.",
)
else:
self.server_state = server_state
def _validate_coef(coef, param):
try:
if coef is not None:
coef = float(coef)
if coef < 0:
raise falcon.HTTPInvalidParam(
'Invalid %s: cannot be smaller then 0' % param, param)
except ValueError:
raise falcon.HTTPInvalidParam('%s not numeric' % param, param)
return coef
def parse_request(request, attr):
""" returns mongo compatible query object, based on the query params provided """
logger.debug('DeviceHistory.parse_request [start]')
limit_val = False
sort = [('ts', pymongo.DESCENDING)]
if 'firstN' in request.params.keys():
try:
limit_val = int(request.params['firstN'])
sort = [('ts', pymongo.ASCENDING)]
except ValueError as e:
logger.error(e)
raise falcon.HTTPInvalidParam('Must be integer.', 'firstN')
elif 'lastN' in request.params.keys():
try:
limit_val = int(request.params['lastN'])
except ValueError as e:
logger.error(e)
raise falcon.HTTPInvalidParam('Must be integer.', 'lastN')
elif 'hLimit' in request.params.keys():
try:
limit_val = int(request.params['hLimit'])
except ValueError as e:
logger.error(e)
raise falcon.HTTPInvalidParam('Must be integer.', 'hLimit')
if attr:
query = {'attr': attr, 'value': {'$ne': ' '}}
ts_filter = {}
if 'dateFrom' in request.params.keys():
ts_filter['$gte'] = dateutil.parser.parse(
request.params['dateFrom'])
if 'dateTo' in request.params.keys():
ts_filter['$lte'] = dateutil.parser.parse(request.params['dateTo'])
if len(ts_filter.keys()) > 0:
query['ts'] = ts_filter
ls_filter = {"_id": False, '@timestamp': False, '@version': False}
req = {
'query': query,
'limit': limit_val,
'filter': ls_filter,
'sort': sort
}
logger.debug('DeviceHistory.parse_request [return]')
logger.debug(req)
return req
def on_post(self, request, response):
"""Validates request and calls pig latin translation library
Required Body Properties:
text -- string of length > 0
Success Response:
Code -- 200
Content -- { translation : string }
Error Response:
Code -- 400 or 500
Content -- { title : string[, description : string]}
"""
if request.content_length in (None, 0):
raise falcon.HTTPBadRequest(
'Request body is empty.',
'The request body must contain JSON.'
)
doc = request.context['doc']
if 'text' not in doc:
raise falcon.HTTPMissingParam('text')
elif not isinstance(doc['text'], basestring):
raise falcon.HTTPInvalidParam(
'The value is not a string.',
'text'
)
elif len(doc['text']) == 0:
raise falcon.HTTPInvalidParam(
'The value is empty.',
'text'
)
text = doc['text']
try:
translation = piglatin.to_pig_latin(text)
except Exception,e:
"""API-specific input validation was handled before calling piglatin.to_pig_latin().
So any errors are unexpected and given generic 500 code.
Error message is retained, if possible"""
description = None
if (len(e.args) > 0):
description = e.args[0]
raise falcon.HTTPInternalServerError(
'Unexpected error',
description
)
def on_get(self, req, resp, orbit_number):
'''GET /t5/orbit/<orbit_number>'''
try:
orbit = CalcOrbit(orbit_number)
except TypeError as err:
raise falcon.HTTPInvalidParam(
msg='orbit_number: {}'.format(orbit_number),
param_name=str(err))
except ValueError as err:
raise falcon.HTTPInvalidParam(
msg='orbit_number: {}'.format(orbit_number),
param_name=str(err))
resp.body = orbit.json()
resp.status = falcon.HTTP_200
def on_post(self, req: falcon.Request, resp: falcon.Response):
"""
post /predict
Predicts the sentiment of an input text using a model trained on movie reviews.
Return value is a score beteen 0 and 1.
Above 0.5 is considered positive sentiment.
Inputs:
text (string)
Outputs:
score (float)
Example input:
{
"text": "this movie really sucked"
}
Example output:
{
"score": 0.1
}
"""
text = req.media.get("text")
if text is None:
raise falcon.HTTPMissingParam("text")
if not isinstance(text, str):
raise falcon.HTTPInvalidParam(
f"expected a string, got a {type(text).__name__}", "text")
resp.media = {"score": predict(text)}
def on_post(self, req: falcon.Request, resp: falcon.Response):
"""
POST /api/translate/fren
Translate french sentence to english (70 word limit).
Input: French text (UTF-8 string)
Output: English text (UTF-8 string)
Example input:
{
"fr": "Bonjour le monde!"
}
Example output:
{
"en": "Hello world!"
}
"""
fr_text = req.media.get("fr")
if fr_text is None:
raise falcon.HTTPMissingParam("fr")
if not isinstance(fr_text, str):
raise falcon.HTTPInvalidParam(
f"expected a string, got a {type(fr_text).__name__}", "fr")
resp.media = {"en": translate_fren(fr_text)}
def on_get(self, req, resp):
"""
---
description: Send an email to the given address
parameters:
- name: email
in: query
description: Email you want to send to
required: true
schema:
type: string
responses:
200:
description: Email was successfully sent
content:
application/json:
schema:
type: string
"""
try:
email = req.params["email"]
send_email_to(email)
resp.status = falcon.HTTP_200
resp.media = {"email": "success"}
except KeyError:
raise falcon.HTTPInvalidParam("You are missing an email parameter",
"Missing Parameter")
def on_get(self, request, response, **kwargs):
"""
Falcon resource method for handling the HTTP request GET method
Falcon API provides: parameters embedded in URL via a keyword
args dict, as well as convenience class variables falcon.HTTP_*
"""
with warehouse.get_source_model_session() as current_model:
#get Source dataset object, referenced in URL path
sources = source.SourceUtil.get_list_of_data_sources(
request.url, auth.get_user_id(request), current_model)
dataset_id = source_parameters.get_requested_dataset_id(
sources, request, response, kwargs)
if warehouse.is_warehouse(dataset_id):
msg = 'Metadata.xml not available for source ID: ' + dataset_id
raise falcon.HTTPInvalidParam(msg, 'source')
dataset = None
for table in current_model['tables']:
table_id = '{}.{}'.format(table['project'], table['name'])
if table_id == dataset_id:
dataset = table
break
iso_xml = geographic_metadata(dataset, current_model)
#return generated XML
response.content_type = 'text/xml'
response.body = iso_xml
def on_get(self, req, resp):
# Validate data
# TODO: Finer error logging and handling,
# differentiate between title or data errors
# and invalid or missing parameter.
try:
title = req.params['title']
data = req.params['data']
data = tuple(map(float, data))
except ValueError:
# TODO: Better error logging message
# Error logs and metrics
req_err.inc()
logger.exception('Invalid query string')
raise falcon.HTTPInvalidParam('Invalid query string',
'title or data')
# Logs and metrics
logger.debug("Received new request")
requests.inc()
# Send image as response
resp.data = plot_it(title, data)
resp.content_type = falcon.MEDIA_PNG
resp.status = falcon.HTTP_200
def on_delete(self, req, resp, orgid):
"""
Remove an Organization specified by the orgid
:param req:
:param resp:
:param appid:
:return:
"""
mapper = self.meta.get('mapper')
o = mapper.organization.Organization.get_by_uid(orgid, user_flag=True)
if o is None:
raise falcon.HTTPInvalidParam('Organization not found', orgid)
if o.status != 'DISABLED':
raise falcon.HTTPConflict(falcon.HTTP_409, 'Organization must be disabled before deletion is possible')
if len(o.users) > 0 or len(o.admins) > 0:
raise falcon.HTTPConflict(
falcon.HTTP_409,
'Users must be deleted or updated before application deletion is possible'
)
mapper.organization.Organization.delete_from_object(o)
resp.body = {"deleted": True}
return True
def param_in_body(self, req, spec, param):
body = req.stream.read().decode('utf-8')
schema = spec.get('schema')
name = param.get('name')
type_ = schema.get('type')
value = body
if param.get('required') and body is None:
raise falcon.HTTPMissingParam(name)
default_func = lambda v: v if type_ is not None else None
check_funcs = {
'string': lambda v: str(v),
'password': lambda v: str(v),
'byte': lambda v: base64.b64decode(str(v)),
'integer': lambda v: int(v),
'long': lambda v: int(v),
'float': lambda v: float(v),
'double': lambda v: float(v),
'boolean': lambda v: bool(v),
'array': json_check,
'object': json_check,
}
try:
value = check_funcs.get(type_, default_func)(value)
self.log.debug('param in body - name: {}, type: {}, value: {}'.format(name, type_, value))
except ValueError as e:
self.log.error_trace(
'value error when check param in body - name: {}, type: {}, value: {}'.format(name, type_, value))
raise falcon.HTTPInvalidParam('invalid param in body', name)
return value
def param_in_header(self, req, spec, param):
headers = req.headers
name = param.get('name').upper().replace('_', '-')
type_ = param.get('type')
value = headers.get(name)
if param.get('required') and value is None:
raise falcon.HTTPMissingParam(name)
default_func = lambda v: v if type_ is not None else None
check_funcs = {
'string': lambda v: str(v),
'password': lambda v: str(v),
'byte': lambda v: base64.b64decode(str(v)),
'integer': lambda v: int(v),
'long': lambda v: int(v),
'float': lambda v: float(v),
'double': lambda v: float(v),
'boolean': lambda v: bool(v),
'array': json_check,
'object': json_check,
}
try:
value = check_funcs.get(type_, default_func)(value)
self.log.debug('param in header - name: {}, type: {}, value: {}'.format(name, type_, value))
except ValueError as e:
self.log.error_trace(
'value error when check param in header - name: {}, type: {}, value: {}'.format(name, type_, value))
raise falcon.HTTPInvalidParam('invalid param in header', name + ':' + value)
if param.get('required') and value is None:
raise falcon.HTTPMissingParam(name)
return value
def on_get(self, req, resp):
'''GET /ct/lbb2/cargogen/sale?<options>'''
self.query_parameters = {
'cargo': None,
'market_uwp': None,
'market_tc': [],
'admin': 0,
'bribery': 0,
'broker': 0,
'quantity': 0
}
LOGGER.debug('query_string = %s', req.query_string)
self.parse_query_string(req.query_string)
try:
cargo = CargoSale(
cargo=self.query_parameters['cargo'],
quantity=self.query_parameters['quantity'],
admin=self.query_parameters['admin'],
bribery=self.query_parameters['bribery'],
broker=self.query_parameters['broker'],
trade_codes=self.determine_trade_codes())
except ValueError as err:
raise falcon.HTTPInvalidParam(
msg='query_string: {}'.format(req.query_string),
param_name=str(err))
resp.body = cargo.json()
resp.status = falcon.HTTP_200
def on_post(self, req, resp, queue):
"""
Handles /collector/$queue post requests.
Queues new data into the given queue located at the ActiveMQ instance.
"""
# If the queue name is not an alphanumeric return error
if not str(queue).isalnum():
raise falcon.HTTPInvalidParam('Invalid queue name.', 'queue')
# Create the message
data = req.media.get('data')
# Check if data is not empty
if not data:
raise falcon.HTTPMissingParam('data')
# Send the message
self.activemq_conn.send(queue,
json.dumps({
'data': data
}).encode(), self.headers)
# Answer the request
resp.media = {'created': json.dumps(data), 'status': 'success'}
# Created a new entry on the queue
resp.status = falcon.HTTP_201
def enforce(self, j, **kargs):
for k in kargs.keys():
if k not in j:
raise falcon.HTTPMissingParam(k)
if type(j[k]) != kargs[k]:
raise falcon.HTTPInvalidParam(
"expected {} to be of type {}".format(k, kargs[k]), k)
def on_get(self, req, resp, *args, **kwargs):
super(ResourceGetEvents, self).on_get(req, resp, *args, **kwargs)
request_event_status = req.get_param("status", False)
if request_event_status is not None:
request_event_status = request_event_status.upper()
if (len(request_event_status) !=
1) or (request_event_status not in [
i.value for i in EventStatusEnum.__members__.values()
]):
raise falcon.HTTPInvalidParam(messages.event_status_invalid,
"status")
response_events = list()
aux_events = self.db_session.query(Event)
if request_event_status is not None:
aux_events = \
aux_events.filter(
Event.status == EventStatusEnum(request_event_status))
if aux_events is not None:
for current_event in aux_events.all():
response_events.append(current_event.json_model)
resp.media = response_events
resp.status = falcon.HTTP_200
def on_delete(self, req, resp, groupid):
"""
Remove a Group specified by the groupid
:param req:
:param resp:
:param groupid:
:return:
"""
mapper = self.meta.get('mapper')
o = mapper.group.Group.get_by_uid(groupid, user_flag=True)
if o is None:
raise falcon.HTTPInvalidParam('Group not found', groupid)
if o.status != 'DISABLED':
raise falcon.HTTPConflict(falcon.HTTP_409, 'Group must be disabled before deletion is possible')
if len(o.users) > 0:
raise falcon.HTTPConflict(
falcon.HTTP_409,
'Users must be deleted or updated before group deletion is possible'
)
mapper.group.Group.delete_from_object(o)
resp.body = {"deleted": True}
return True
def on_get(self, req, resp, *args, **kwargs):
super(ResourceGetRandomQuestion, self).on_get(req, resp, *args,
**kwargs)
category_filter = req.get_param("category", False)
if category_filter is not None:
if category_filter not in [
i.value for i in CategoryEnum.__members__.values()
]:
raise falcon.HTTPInvalidParam(messages.event_status_invalid,
"category")
query = self.db_session.query(Question).filter().order_by(func.rand())
if category_filter is not None:
query = query.filter(
Question.category == CategoryEnum(category_filter))
question = query.first()
print(question.json_model)
query = self.db_session.query(Answer, AnswerQuestionAssiation.is_correct) \
.join(AnswerQuestionAssiation).filter(question.id == AnswerQuestionAssiation.id_question)
answers = query.all()
response = question.json_model
response["answers"] = []
for a in answers:
aux = a[0].json_model
aux["is_correct"] = a[1]
response["answers"].append(aux)
resp.media = response
resp.status = falcon.HTTP_200
def get_country(self, country):
try:
if country not in self.cache:
self.cache[country] = getattr(countries, country)()
return self.cache[country]
except AttributeError:
raise falcon.HTTPInvalidParam("", "country")
def on_put(self, req, resp, discordId):
self.authorize(req)
try:
self.db.updateUser(discordId,req.media)
except Exception as error:
print(error)
raise falcon.HTTPInvalidParam("Unknown user", "discordId")
def on_post(self, req, resp, body):
if "changes" not in body:
raise falcon.HTTPInvalidParam(
"Compilation request requires a changes field", "changes")
resp.body = self.validate(body["changes"])
resp.status = falcon.HTTP_200
def on_get(self, req, resp):
try:
key_id = req.params['id']
if key_id == '':
raise ImportError
except ImportError:
raise falcon.HTTPInvalidParam('Parameter cannot be blank', 'url')
except:
raise falcon.HTTPMissingParam(param_name='id (ID of video)')
with open("yte-logs.json", "r+") as logs_file:
logs = json.load(logs_file)
logs_file.close
if key_id in logs:
resp.content_type = 'json'
resp.status = falcon.HTTP_200
resp.body = json.dumps(logs[key_id])
if logs[key_id]['status'] != '200 OK':
Process(target=self.main, args=(key_id, )).start()
else:
check_vid = YouTube('https://www.youtube.com/watch?v=' + key_id)
if int(check_vid.length) > 600:
raise falcon.HTTPFailedDependency(
description='Video is more than 10 mins long')
log_create(key_id)
Process(target=self.main, args=(key_id, )).start()
resp.content_type = 'json'
resp.status = falcon.HTTP_200
body = {
'response': 'Process started, GET request again to see status.'
}
resp.body = json.dumps(body)
def param_in_path(self, matched_uri, param):
type_ = param.get('type')
name = param.get('name')
value = matched_uri.groupdict().get(name)
self.log.debug(value)
default_func = lambda v: v if type_ is not None else None
check_funcs = {
'string': lambda v: str(v),
'password': lambda v: str(v),
'byte': lambda v: base64.b64decode(str(v)),
'integer': lambda v: int(v),
'long': lambda v: int(v),
'float': lambda v: float(v),
'double': lambda v: float(v),
'boolean': lambda v: bool(v),
}
if param.get('required') and value is None:
raise falcon.HTTPMissingParam(name)
try:
value = check_funcs.get(type_, default_func)(value)
self.log.debug(
'param in path - name: {}, type: {}, value: {}'.format(
name, type_, value))
except ValueError as e:
self.log.error_trace(
'value error when check param in path - name: {}, type: {}, value: {}'
.format(name, type_, value))
raise falcon.HTTPInvalidParam('invalid param in path', name)
return value
def param_in_query(self, req, param):
name = param.get('name')
type_ = param.get('type')
default_func = lambda p: req.get_param(p
) if type_ is not None else None
check_funcs = {
'string': lambda p: req.get_param(p),
'password': lambda p: req.get_param(p),
'byte': lambda p: base64.b64decode(req.get_param(p)),
'integer': lambda p: req.get_param_as_int(p),
'long': lambda p: req.get_param_as_int(p),
'float': lambda p: float(req.get_param(p)),
'double': lambda p: float(req.get_param(p)),
'array': lambda p: req.get_param_as_dict(p),
'object': lambda p: req.get_param_as_dict(p),
'boolean': lambda p: req.get_param_as_bool(p),
}
value = None
try:
value = check_funcs.get(type_, default_func)(name)
self.log.debug(
'param in query - name: {}, type: {}, value: {}'.format(
name, type_, value))
except ValueError as e:
self.log.error_trace(
'value error when check param in query - name: {}, type: {}, value: {}'
.format(name, type_, value))
raise falcon.HTTPInvalidParam('invalid param in query', name)
if param.get('required') and value is None:
raise falcon.HTTPMissingParam(name)
return value
def check_mandatory_query_param(params, field, ftype=None):
if (field not in params.keys()) or (len(params[field]) == 0):
raise falcon.HTTPMissingParam(field)
if ftype is not None:
if not ftype(params[field]):
raise falcon.HTTPInvalidParam(
'%s must be of type %s' % (field, ftype.__name__), field)
