def pesquisa_especie(especie=None): especies = Especie.find_pesquisa(especie) cabeca = txml.Element('especies') for (idespecie, especie, genero, habitat, coordenadas, notas, detalhes, nomecomum, codigo, validacao, datacriacao) in especies: element = txml.SubElement(cabeca, 'c_especie') elemento1 = txml.SubElement(element,'idespecie') elemento2 = txml.SubElement(element,'especie') elemento3 = txml.SubElement(element,'nomecomum') elemento4 = txml.SubElement(element,'habitat') elemento1.text = "{}".format(idespecie) elemento2.text = "{}".format(especie) elemento3.text = "{}".format(nomecomum) elemento4.text = "{}".format(habitat) my_xml = txml.tostring(cabeca) b = Response() b.set_data(my_xml) b.status = "200" b.get_json(force=False, silent=True, cache=True) b.mimetype = "application/xml" return b.get_data()
def delete_reino(idreino): reino = Reino.find_by_id(idreino) if reino is not None: Reino.delete(idreino) b = Response() b.set_data("apagado id= {}".format(idreino)) b.status = "200" b.get_json(force=False, silent=True, cache=True) b.mimetype = "application/xml" return b.get_data()
def args(response: Response): data = response.get_json() if data: items = data['items'].copy() _filter: str = request.args.get('filter') _filter_title: str = request.args.get('filter_title') _filter_description: str = request.args.get('filter_description') limit: int = request.args.get('limit', type=int) if _filter: items.extend(filter_all(_filter, items)) if _filter_title: items.extend(filter_title(_filter_title, items)) if _filter_description: items.extend(filter_description(_filter_description, items)) if limit: items = items[:limit] data['items'] = items response.data = json.dumps(data) return response
def assert_user_resp(self, expect: Expect, resp: Response, expected: EqualDataMixin, http_status: Union[ HTTPStatus, range] = HTTPStatus.OK, msg: str = None): """ Assert user response is equal. :param expect: Expected result; one of Expect.SUCCESS or Expect.FAILURE :param resp: response body :param expected: expected entity :param http_status: expected HTTPStatus or range of status codes :param msg: assert error message """ if msg is None: msg = "" self.assertTrue(resp.is_json) resp_body = resp.get_json() if expect == Expect.SUCCESS: self.assert_ok(resp.status_code) self.assert_success_response(resp_body) self.assert_body_entry(resp_body, RESULT_ONE_USER, MatchParam.EQUAL, value=expected) else: if isinstance(http_status, HTTPStatus): self.assert_response_status_code(http_status, resp.status_code, msg=msg) self.assertTrue(resp.is_json) self.assert_error_response(resp_body, http_status, '', MatchParam.IGNORE, msg=msg)
def acquire_from_json(self, resp: Response): _json = resp.get_json() self.id = _json['id'] self.email = _json['email'] self.firstname = _json['firstname'] self.lastname = _json['lastname'] _stories = _json['stories'] for st in _stories: self.stories.append(st)
def after_request(self, response: Response) -> Response: g.use.status_code = response.status_code g.use.response['content_length'] = response.content_length g.use.response['mimetype'] = response.mimetype g.use.response['headers'] = response.headers g.use.response['body'] = response.get_json() return response
def safellyGetFlaskResponseJson(response: Response): jsonBody = None try: jsonBody = response.get_json(force=True) except Exception as exception: jsonBody = {} log.log( safellyGetFlaskResponseJson, f'Not possible to get response body. Returning {jsonBody} by default', exception=exception) return jsonBody
def validate_error_response(self, resp: flask.Response, error: t.Union[errors.BaseError, t.Type[Exception]]): def assertEqual(x, y): assert x == y def assertDictEqual(x, y): assert str(x) == str(y) assertEqual = self.assertEqual if hasattr( self, 'assertEqual') else assertEqual assertDictEqual = self.assertDictEqual if hasattr( self, 'assertDictEqual') else assertDictEqual if inspect.isclass(error): assertEqual(error.__qualname__, resp.get_json().get('error').get('type')) else: assertEqual(error.status_code, resp.status_code) assertDictEqual(errors.format_error_content(error), resp.get_json())
def flask_validate_response( request: flask.Request, response: flask.Response ) -> ValidationResult: response_data = response.get_json(force=True, silent=True) op_name = _api_operation_for_request(request) doc_type = _response_schema_types.get(op_name) # Only do response validation if it is a successful response status if doc_type is not None and (200 <= response.status_code < 299): validation_request = ValidationRequest( provider_doc_type=doc_type, request_data=response_data ) return request_validator(validation_request) else: return ValidationResult(errors=[], error_msg=None)
def _log_response(response: Response): # pylint: disable=unused-variable data = "INVALID" try: data = response.get_json() if response.data else "EMPTY" except Exception: LOGGER.error("Exception while reading json of response.") LOGGER.info( "Responding to request %s %s: %s - Body: %s", request.method, request.full_path, response.status_code, data, ) return response
def redact_response(self, method:str, response:Response): ''' Redact a response payload bbased on the provided schema ''' data = response.get_json() if method in self.schema: method_schema = self.schema[method].copy() redactions = method_schema.get('redact', []) for redaction in redactions: redaction_path = redaction.split('.') self._redact(redaction, redaction_path, data) response.set_data(dumps(data)) return response
def log_request(r: Response) -> Response: latency_ms = (time.perf_counter() - g.start) * 1000 rl = RequestLogEntry( r.status_code, request.method, request.path, request.args, None if not log_payloads else request.get_json(silent=True), None if not log_payloads else r.get_json(silent=True), request.remote_addr, request.headers.get("X-Forwarded-For"), latency_ms, r.headers.get("X-Cache-Hit", "0") == "1", ) logging.getLogger("request").info(asdict(rl)) return r
def assert_role_resp(self, expected: EqualDataMixin, resp: Response, msg: str = None): """ Assert roles list responses are equal. """ if msg is None: msg = "" self.assert_ok(resp.status_code) self.assertTrue(resp.is_json) resp_body = resp.get_json() self.assert_success_response(resp_body) self.assert_body_entry(resp_body, RESULT_ONE_ROLE, MatchParam.EQUAL, value=expected)
def assert_roles_list_resp(self, expected: list[EqualDataMixin], resp: Response, msg: str = None): """ Assert roles list responses are equal. """ if msg is None: msg = "" self.assert_ok(resp.status_code) self.assertTrue(resp.is_json) resp_body = resp.get_json() self.assert_success_response(resp_body) self.assert_body_entry(resp_body, RESULT_LIST_ROLES, MatchParam.IGNORE) resp_roles = resp_body[RESULT_LIST_ROLES] self.assert_roles_list(expected, resp_roles, msg=msg)
def upload(): dico = {} dico['metadata'] = {} output_dir = os.path.join(os.getcwd(),'output_dir/') if request.method == 'POST': file = request.files['file'] f_name = request.files["file"].filename doc = Document(file, f_name) #aiguille l'extraction des métadonnées dépendant de l'extension du document _data = doc.refersTo() if 'error' not in list(_data.keys()): content = "" for key, value in _data.items(): if key != "content": dico['metadata'][key] = value else: dico[key] = value dico['metadata']['mime_type'] = request.files["file"].content_type else: #resp = json.dumps(file_content['error'], ensure_ascii=False) resp = jsonify({'message' : file_content['error']}) resp.status_code = 400 return resp try: #bucket_name = 'boto3-etienne' new_file = f_name.split('.')[0] +'.json' s3 = boto3.client('s3') response = jsonify(dico) response.status_code = 200 s3.upload_fileobj(BytesIO(json.dumps(Response.get_json(response), sort_keys=True, indent=2).encode('utf-8')), bucket_name, new_file) except: print("Can't write json to S3") return jsonify(dico) #return json.dumps(dico, ensure_ascii=False).encode('utf8') else: resp = jsonify({'message' : 'Cette méthode ne peut être exécuté que par un POST'}) resp.status_code = 405 return resp
def assert_users_list_resp(self, expect: Expect, resp: Response, expected: list[EqualDataMixin], http_status: Union[ HTTPStatus, range] = HTTPStatus.OK, msg: str = None): """ Assert users list responses are equal. :param expect: Expected result; one of Expect.SUCCESS or Expect.FAILURE :param resp: response body :param expected: expected list :param http_status: expected HTTPStatus or range of status codes :param msg: assert error message """ if msg is None: msg = "" self.assertTrue(resp.is_json) resp_body = resp.get_json() if expect == Expect.SUCCESS: self.assert_ok(resp.status_code) self.assert_success_response(resp_body) self.assert_body_entry(resp_body, RESULT_LIST_USERS, MatchParam.IGNORE) resp_users = resp_body[RESULT_LIST_USERS] self.assert_users_list(expected, resp_users, msg=msg) else: if isinstance(http_status, HTTPStatus): self.assert_response_status_code(http_status, resp.status_code, msg=msg) self.assertTrue(resp.is_json) self.assert_error_response(resp_body, http_status, '', MatchParam.IGNORE, msg=msg)
def validate_error_response(self, resp: flask.Response, error: errors.BaseError): if hasattr(self, 'assertEqual') and hasattr(self, 'assertDictEqual'): self.assertEqual(error.status_code, resp.status_code) self.assertDictEqual(errors.format_error_content(error), resp.get_json())
def after_request(resp: Response) -> Response: if isinstance(resp.get_json(), dict): # use replace not json.load/dumps for speed resp.data = resp.data.replace(b'{', bytes('{\n"request_id":"%s",' % get_request_id(), 'utf-8'), 1) return resp
def _get_json(resp: Response) -> dict: return resp.get_json()