def on_post(cls, req, resp): """Run the indicated runnable passing the given message.""" try: message = req.body['message'] runnable = req.body['runnable'] except KeyError as ke: raise falcon.HTTPMissingParam(ke.args[0]) from None session = req.headers.get('API-SESSION') if not session: raise falcon.HTTPMissingParam('API-SESSION') req.context['session'] = ObjectId(session) req.context['internal'] = True cls.logger.debug('Running runnable %s', runnable, extra={'session': session}) runnable_class = cls.api.runnables[runnable] runnable_class(req).run_local(message) resp.body = { 'runnable': runnable, 'message': message, } cls.logger.debug('runnable %s status: OK', runnable, extra={'session': session})
def on_patch(self, req, resp): """Method takes either sparql statement or predicate and object and updates the Resource. Args: req -- Request resp -- Response """ doc_uuid = req.get_param('uuid') if not doc_uuid: raise falcon.HTTPMissingParam('uuid') predicate = req.get_param('predicate') or None if not predicate: raise falcon.HTTPMissingParam('predicate') object_ = req.get_param('object') or None if not object_: raise falcon.HTTPMissingParam('object') doc_type = req.get_param('doc_type') or None if self.__update__(doc_id=doc_uuid, doc_type=doc_type, field=predicate, value=object_): resp.status = falcon.HTTP_202 resp.body = json.dumps(True) else: raise falcon.HTTPInternalServerError( "Error with PATCH for {}".format(doc_uuid), "Failed setting {} to {}".format(predicate, object_))
def on_post(self, request, resp): """ Issue authenticated session cookie, if request credentials are valid """ username_post_field, password_post_field = 'username', 'password' # fetch POSTed auth credentials try: request_username = request.params[username_post_field] except KeyError: raise falcon.HTTPMissingParam(username_post_field) try: request_password = request.params[password_post_field] except KeyError: raise falcon.HTTPMissingParam(password_post_field) # Authenticate try: user_id, decoded_token = KeycloakBackend.authenticate( request_username, request_password) if user_id is None: raise LoginInvalid('Bad Login!') #Indicate user is logged in auth.create_login_session(user_id, request, oidc=decoded_token) except LoginInvalid as e: title = 'Unauthorized' description = 'Please check the supplied username or password.' raise falcon.HTTPUnauthorized(title, description) from e
def on_post(self, req, resp, pid=None): self.__set_rest_url__("datastream", pid) namespace = req.get_param("namespace") or\ "info:fedora/fedora-system:def/relations-external#" predicate = req.get_param("predicate") or None if not predicate: raise falcon.HTTPMissingParam( "Islandora Relationship POST missing predicate param", "predicate") object_ = req.get_param("object") or None if not object_: raise falcon.HTTPMissingParam( "Islandora POST missing object param", "object") if self.__add__(namespace, predicate, object_): message = """Added relationship {} from {} to {}""".format( predicate, pid, object_) resp.status = falcon.HTTP_201 resp.body = json.dumps({"message": message}) else: raise resp.status = falcon.HTTP_400 resp.body = json.dumps( {"message": "failed to add relationship to {}".format(pid)})
def on_post(self, req, resp): """Handle user login POST requests. Returns an authenticated API session token HTTP POST parameters: username -- New user to create (Required) password -- New user's password (Required) """ username_post_field, password_post_field = 'username', 'password' try: request_username = req.params[username_post_field] except KeyError: raise falcon.HTTPMissingParam(username_post_field) try: request_password = req.params[password_post_field] except KeyError: raise falcon.HTTPMissingParam(password_post_field) stored_hash = user.get_user_hash(user_storage, request_username) if auth.check_password(request_password, stored_hash): # log in user session.create_login_session(request_username, req) resp.media = {'message': 'Login success!'} return raise falcon.HTTPUnauthorized(title='Login incorrect')
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): """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 on_post(self, req, resp, uuid=None) -> None: jwt = decode_jwt(req.auth) try: doc = req.context.doc except AttributeError as e: logging.debug(str(e)) raise falcon.HTTPBadRequest('JSON Body Missing') try: old_password = doc["oldpassword"] except KeyError as e: logging.debug(str(e)) raise falcon.HTTPMissingParam("oldpassword") try: new_password = doc["newpassword"] except KeyError as e: logging.debug(str(e)) raise falcon.HTTPMissingParam("newpassword") if uuid is None: uuid = jwt['user_uuid'] # If SQL connection is gone, reconnect if not self.mysql.is_connected(): logging.debug("MySQL connection dropped, reconnecting.") self.mysql.reconnect(attempts=3, delay=1) # SQL Result cursor = self.mysql.cursor() cursor.execute("SELECT `password`, `uuid` FROM `users` WHERE `uuid`=%s LIMIT 1", (uuid,)) for (password, uuid) in cursor: sql_password = password sql_uid = uuid break # SQL End new_pass_hash = new_hash(new_password) if hash_verify(old_password, sql_password): print("hash match") else: raise falcon.HTTPUnauthorized( "Old password is invalid", "The old password you entered does not match the one we have on record." ) cursor.execute("UPDATE `users` SET password=%s WHERE `uuid`=%s LIMIT 1", (new_pass_hash, uuid,)) self.mysql.commit() cursor.close() self.mysql.reconnect(attempts=3, delay=1) resp.context.result = { "title": "Password changed" }
def CreateProject(**request_handler_args): req = request_handler_args['req'] authUser(req, request_handler_args['resp'], ['createProject']) doc = req.context['doc'] try: user_ids = [] for x in range(len(doc['users'])): user_ids.append(ObjectId(doc['users'][x])) except InvalidId as e: raise falcon.HTTPBadRequest('Bad Request', str(e)) except KeyError as e: raise falcon.HTTPMissingParam('users') try: project_users = User.objects.raw({'_id': {'$in': user_ids}}) except User.DoesNotExist: raise falcon.HTTPNotFound() try: project_schema = Schema.objects.get( {'_id': ObjectId(doc['acl_schema'])}) except InvalidId as e: raise falcon.HTTPBadRequest('Bad Request', str(e)) except KeyError as e: raise falcon.HTTPMissingParam('acl_schema') try: project = Project(name=doc['name'], acl_schema=project_schema, paths=doc['paths'], users=project_users) except KeyError as e: raise falcon.HTTPBadRequest('Invalid Project Object', "Project JSON Object is invalid. %s" % e) else: try: project.save() except project.ValidationError as e: raise falcon.HTTPBadRequest("Validation Error", e.message) else: #pprint.pprint(project) request_handler_args['resp'].status = falcon.HTTP_201 project.uri = req.uri + '/' + str(project._id) request_handler_args['resp'].location = project.uri request_handler_args['req'].context['result'] = project.to_dict() req.context['logger'].info({ 'action': 'createProject', 'message': "'%s' project with id of %s was created successfully." % (project.name, project._id) })
def on_get(self, req, resp): param = req.get_param("target").split(':') self._target = param[0] self._port = param[1] resp.set_header('Content-Type', CONTENT_TYPE_LATEST) if not self._target: msg = "No target parameter provided!" logging.error(msg) raise falcon.HTTPMissingParam('target') try: socket.gethostbyname(self._target) except socket.gaierror as excptn: msg = "Target does not exist in DNS: {0}".format(excptn) logging.error(msg) resp.status = falcon.HTTP_400 resp.body = msg else: registry = AristaMetricsCollector( self._config, exclude=self._exclude, target=self._target, port=self._port ) collected_metric = generate_latest(registry) resp.body = collected_metric
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 on_post(self, req, resp, dataset_id, dataset_dto): """Return suggests to use with autocomplete This method will return suggestions to be used on frontend while users input the entity name. TODO: this should only return entities that exists on dataset, right now returns all possible entities. :param int dataset_id: The id of the dataset to autocomplete :param DTO dataset_dto: The Dataset DTO from dataset_id (from hook) :param str input: The input to autocomplete (from body) :returns: A list with entities and full text :rtype: Object """ try: body = common_hooks.read_body_as_json(req) input_text = body['input'] except KeyError as err: raise falcon.HTTPMissingParam("input") entity_dao = data_access.EntityDAO(dataset_dto.dataset_type, dataset_id) # Extract suggestion from elasticsearch suggestion = entity_dao.suggest_entity(input_text) # Return a response resp.body = json.dumps(suggestion) resp.content_type = 'application/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, 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 on_get(self, req, resp, project, ident): query = build_query(req.env, project) if 'version' in req.params: version = req.params['version'] else: raise falcon.HTTPMissingParam('version') if version == 'latest': version = query('latest') if 'family' in req.params: family = req.params['family'] else: family = 'C' if family == 'B': #DT compatible strings are quoted in the database ident = parse.quote(ident) symbol_definitions, symbol_references, symbol_doccomments = query( 'ident', version, ident, family) resp.body = json.dumps({ 'definitions': [sym.__dict__ for sym in symbol_definitions], 'references': [sym.__dict__ for sym in symbol_references], 'documentations': [sym.__dict__ for sym in symbol_doccomments] }) resp.status = falcon.HTTP_200
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 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_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 UpdateACLSchema(**request_handler_args): req = request_handler_args['req'] authUser(req, request_handler_args['resp'], ['createACLSchema']) doc = req.context['doc'] try: schema = Schema.objects.get( {"_id": ObjectId(request_handler_args['uri_fields']['id'])}) except InvalidId as e: raise falcon.HTTPMissing('Bad Request', str(e)) except Schema.DoesNotExist: raise falcon.HTTPNotFound() else: try: schema.name = doc['name'] schema.schema = doc['schema'] schema.modified = datetime.datetime.now() except KeyError as e: raise falcon.HTTPMissingParam(str(e)) try: schema.save() except schema.ValidationError as e: raise falcon.HTTPBadRequest("Validation Error", e.message) else: for project in Project.objects.raw({"acl_schema": schema._id}): project.save() schema.uri = req.uri + '/' + str(schema._id) request_handler_args['resp'].location = schema.uri request_handler_args['req'].context['result'] = schema.to_dict() req.context['logger'].info({ 'action': 'updateACLSchema', 'message': "'%s' ACLSchema with id of %s was updated successfully." % (schema.name, schema._id) })
def CreateACLSchema(**request_handler_args): req = request_handler_args['req'] authUser(req, request_handler_args['resp'], ['createACLSchema']) doc = req.context['doc'] try: schema = Schema(name=doc['name'], schema=doc['schema']) except KeyError as e: raise falcon.HTTPMissingParam(str(e)) else: try: schema.save() except Schema.ValidationError as e: raise falcon.HTTPBadRequest("Validation Error", e.message) else: request_handler_args['resp'].status = falcon.HTTP_201 schema.uri = req.uri + '/' + str(schema._id) request_handler_args['resp'].location = schema.uri request_handler_args['req'].context['result'] = schema.to_dict() req.context['logger'].info({ 'action': 'createACLSchema', 'message': "'%s' ACLSchema with id of %s was created successfully." % (schema.name, schema._id) })
def on_get(self, req, resp): # """Handles GET requests""" # if req.client_accepts_msgpack or "msgpack" in req.content_type: # serializer = msgpack # resp.content_type = "application/x-msgpack" # else: serializer = json resp.content_type = "application/json" image_url = req.get_param("imageUrl") if not image_url: print('get request didnt specify a url:' + str(req)) raise falcon.HTTPMissingParam("imageUrl") else: print('hydra_tg falcon on_get got url ' + image_url) try: # thresholds = req.get_param("thresholds") # if thresholds: # response = requests.get(image_url,thresholds=thresholds) # else: # response = requests.get(image_url) response = requests.get(image_url) img_arr = cv2.imdecode(np.asarray(bytearray(response.content)), 1) detected = self.detect( img_arr, url=image_url) #url being sent for logging self.write_log(image_url, detected) resp.data = serializer.dumps({"data": detected}) resp.status = falcon.HTTP_200 except: raise falcon.HTTPBadRequest("Something went wrong :(", traceback.format_exc())
def delete_announcement(self, announcement_id: int, force_delete=False) -> bool: """delete announcement. Args: announcement_id ([int]): announcement id. Returns: [bool]: True """ if announcement_id is None: raise falcon.HTTPMissingParam("announcement id") try: announcement_name_search = self._get_announcement_key_name_by_id( announcement_id, raise_error=not force_delete) except falcon.HTTPServiceUnavailable as e: falcon.falcon.HTTPServiceUnavailable( title=e.title, description= "Add force delete to dismiss this error, and delete same id announcements." ) for name in announcement_name_search: self.redis_announcement.delete(name) return True
def on_post(self, req, resp): try: fromAccNum = req.get_param('fromAccNum') toAccNum = req.get_param('toAccNum') amount = req.get_param('amount') except KeyError: raise falcon.HTTPMissingParam( 'Missing fromAccNum, toAccNum or amount', 'fromAccNum, toAccNum and amount are required.') try: url = PAYMENT_SERVICE_URL + 'pay' payload = { 'fromAccNum': fromAccNum, 'toAccNum': toAccNum, 'amount': amount } res = requests.post(url, json=payload) if res.status_code != codes.ok: raise NotFound("Cannot execute payment from " + \ "%s to %s amount %s, resp %s, status code %s" \ % (fromAccNum, toAccNum, amount, res.text, res.status_code)) else: resp.context = res.json() resp.status = falcon.HTTP_200 except ConnectionError as e: raise HTTPBadRequest("Payment service connection error: %s." % e)
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 on_post(self, req, resp, user_id=None): """Handles POST requests. (POST: /users)""" # TODO: need to check email isn't aleady in the db # sqlalchemy.exc.IntegrityError: (sqlite3.IntegrityError) UNIQUE constraint failed: users.email logger.info('POST /users') email = req.media['email'] if self.get_user_by_email(email): raise falcon.HTTPBadRequest( "Email in use", "The email entered is already in use. Please use a different email" ) try: new_user = User( first_name=req.media['first_name'], last_name=req.media['last_name'], email=req.media['email'], ) except (TypeError, KeyError) as e: split_str = str(e).split(':') missing_params = split_str[1] if len( split_str) > 1 else split_str[0] missing_params = missing_params.strip().replace("'", "") raise falcon.HTTPMissingParam(missing_params) if new_user: self.session.add(new_user) self.session.commit() resp.status = falcon.HTTP_CREATED resp.media = new_user.as_dict()
def read_pair_list(req, resp, resource, params): try: body = common_hooks.read_body_as_json(req) if "distance" not in body: raise falcon.HTTPMissingParam("distance") if not isinstance(body["distance"], list) and\ len(body["distance"]) != 2: msg = ("The param 'distance' must contain a list of two" "entities.") raise falcon.HTTPInvalidParam(msg, "distance") params["entities_pair"] = (body["distance"][0], body["distance"][1]) except KeyError as err: raise falcon.HTTPMissingParam(err(str))
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)
def _parse_strategy(cls, strategy_str: Optional[str]) -> Strategy: if not strategy_str: raise falcon.HTTPMissingParam("strategy") strategy = strategies.from_name(strategy_str) if not strategy: raise falcon.HTTPInvalidParam( f"strategy must be one of: {', '.join(get_all_strategies().keys())}", "strategy") return strategy