def post(self, tenant): '''Create Person''' APIAdminCommon.verifySecurityOfAdminAPICall( appObj, request, tenant) content_raw = request.get_json() content = marshal(content_raw, getPersonModel(appObj)) if "guid" in content_raw: raise BadRequest("Can not supply guid when creating person") del content["guid"] requiredInPayload(content, []) try: def someFn(connectionContext): personDict = CreatePerson(appObj, connectionContext, None, 'a', 'b', 'c') return GetPerson(appObj, personDict["guid"], connectionContext) personObj = appObj.objectStore.executeInsideTransaction(someFn) except customExceptionClass as err: if (err.id == 'TryingToCreateDuplicateUserException'): raise BadRequest(err.text) raise Exception('InternalServerError') except: raise InternalServerError return personObj.getJSONRepresenation(), 201
def wrap_response_with_data(self, resp, code=200): mask = self.mask if has_app_context(): mask_header = current_app.config['RESTX_MASK_HEADER'] mask = request.headers.get(mask_header) or mask if isinstance(resp, dict) and all(k in resp for k in ['metadata', 'data']): return wrap_response(marshal(resp['data'], self.fields, self.envelope, mask), metadata=marshal(resp['metadata'], self.metadata), http_code=code) else: return wrap_response(marshal(resp, self.fields, self.envelope, mask), http_code=code)
def get(self) -> List[Dict]: """ Return the last record for all massifs. """ with session_scope() as sess: results = (sess.query( BraRecord, func.lag(BraRecord.br_id).over( order_by=BraRecord.br_production_date, partition_by=BraRecord.br_massif, ).label("previous_bra_id"), func.lead(BraRecord.br_id).over( order_by=BraRecord.br_production_date, partition_by=BraRecord.br_massif, ).label("next_bra_id"), ).filter( BraRecord.br_production_date.cast(Date) == select([ func.max(BraRecord.br_production_date.cast(Date)) ])).options(subqueryload(BraRecord.risks)).options( subqueryload(BraRecord.snow_records)).options( subqueryload(BraRecord.fresh_snow_records)).options( subqueryload(BraRecord.weather_forecasts)).options( subqueryload( BraRecord.risk_forecasts)).options( subqueryload(BraRecord.massif))) final = [] for res in results.all(): encoded_bra_record = marshal(res.BraRecord, bra_model) encoded_bra_record["previous_bra_id"] = (str( res.previous_bra_id) if res.previous_bra_id else None) encoded_bra_record["next_bra_id"] = (str(res.next_bra_id) if res.next_bra_id else None) final.append(encoded_bra_record) return final
def create_contact(json_data): contact = Contact.query.filter_by(address=json_data['address']).first() if contact: # Check if room exist or was deleted contact_room = Room.query.filter_by(hash=json_data['address']).first() if contact_room: raise Conflict("Contact address already in DB") contact_room = Room(name=contact.name or contact.nickname, hash=contact.address, private=True) contact_room.save() contact_room.members.append(contact) contact_room.save() else: contact = Contact(**json_data) contact_room = contact.save() logging.info(f"Contact {contact.name} created") g.socketio.emit('newContact', marshal(contact_room, room_model), namespace="/api/internal") return contact
def incident_action(user, action_type, incident, comment=None, task=None, subtask=None, target_users=None, extra=None): if not target_users: target_users = [] incident.last_updated = datetime.now() action = IncidentLog(user=user, action_type=action_type, incident_id=incident.id, comment=comment, task=task, subtask=subtask, target_users=target_users, extra=extra) db.session.add(action) db.session.commit() action_marshalled = marshal(action, activity_model) emit_incident('INCIDENT_ACTIVITY', { 'id': incident.id, 'activity': action_marshalled, 'code': 200 }, incident)
def inner(*args, **kwargs): rv = func(*args, **kwargs) # If a Flask response has been made already, it is passed through unchanged if isinstance(rv, Response): return rv if schema: serialized = schema.dump(rv) # Validate data if asked to (throws) if validate: errs = schema.validate(serialized) if errs: raise InternalServerError( description= "Server attempted to return invalid data") else: from flask_restx import marshal serialized = marshal(rv, model_from_parser) if not _is_method(func): # Regular route, need to manually create Response return jsonify(serialized), status_code return serialized, status_code
def get(self, dataset_uuid, study_id=None, user=None): """ Fetch a specific dataset for a given study """ args = self._get_parser.parse_args() prop_id_to_name = get_property_map(key="id", value="name") prop_name_to_id = reverse_map(prop_id_to_name) # Used for helper route using only dataset_uuid if study_id is None: study_id = find_study_id_from_lvl1_uuid("dataset", dataset_uuid, prop_name_to_id) if study_id is None: raise Exception( f"Dataset not found in any study (uuid = {dataset_uuid})") study = Study.objects().get(id=study_id) study_json = marshal(study, study_model) # The converter is used for its get_entry_by_name() method study_converter = FormatConverter(mapper=prop_id_to_name) study_converter.add_api_format(study_json["entries"]) datasets_entry = study_converter.get_entry_by_name("datasets") dataset_nested_entry = datasets_entry.value.find_nested_entry( "uuid", dataset_uuid)[0] # The "dataset_nested_entry" entry is a NestedEntry (return list of dict) if args["entry_format"] == "api": return dataset_nested_entry.get_api_format() elif args["entry_format"] == "form": return dataset_nested_entry.get_form_format()
def test_marshal(self): model = OrderedDict([('foo', fields.Raw)]) marshal_dict = OrderedDict([('foo', 'bar'), ('bat', 'baz')]) output = marshal(marshal_dict, model) assert isinstance(output, dict) assert not isinstance(output, OrderedDict) assert output == {'foo': 'bar'}
def test_marshal_wildcard_nested(self): nest = fields.Nested( OrderedDict([('thumbnail', fields.String), ('video', fields.String)])) wild = fields.Wildcard(nest) wildcard_fields = OrderedDict([('*', wild)]) model = OrderedDict([('preview', fields.Nested(wildcard_fields))]) sub_dict = OrderedDict([('9:16', { 'thumbnail': 24, 'video': 12 }), ('16:9', { 'thumbnail': 25, 'video': 11 }), ('1:1', { 'thumbnail': 26, 'video': 10 })]) marshal_dict = OrderedDict([('preview', sub_dict)]) output = marshal(marshal_dict, model) assert output == { 'preview': { '1:1': { 'thumbnail': '26', 'video': '10' }, '16:9': { 'thumbnail': '25', 'video': '11' }, '9:16': { 'thumbnail': '24', 'video': '12' } } }
def on_viewing_incident(data): try: incident_id = data['incidentId'] send_changes_only = data['sendChangesOnly'] except KeyError: return if not current_user.has_incident_access(incident_id): return if incident_id not in viewing_incidents.keys(): viewing_incidents[incident_id] = {current_user.id: datetime.utcnow().timestamp()} elif incident_id in viewing_incidents.keys() and current_user.id not in viewing_incidents[incident_id]: viewing_incidents[incident_id][current_user.id] = datetime.utcnow().timestamp() else: changed = False now = datetime.utcnow().timestamp() viewing_incidents[incident_id][current_user.id] = now for x_key, x_value in viewing_incidents.items(): for y_key, y_value in list(x_value.items()): if now - y_value > 120: changed = True del viewing_incidents[x_key][y_key] if not changed and send_changes_only: return join_room(f'{incident_id}-viewing') users_marshalled = [] users = User.query.filter(User.id.in_(viewing_incidents[incident_id].keys())).all() for x in users: users_marshalled.append(marshal(x, user_model_without_group)) emit('viewing_incident', {'users': users_marshalled}, namespace='/', room=f'{incident_id}-viewing')
def test_marshal_wildcard_with_skip_none(self): wild = fields.Wildcard(fields.String) model = OrderedDict([('foo', fields.Raw), ('*', wild)]) marshal_dict = OrderedDict([('foo', None), ('bat', None), ('baz', 'biz'), ('bar', None)]) output = marshal(marshal_dict, model, skip_none=True) assert output == {'baz': 'biz'}
def test_list_fields_with_raw(self): family_fields = { 'members': fields.List(fields.Raw) } result = mask.apply(family_fields, 'members{name}') data = {'members': [ {'name': 'John', 'age': 42}, {'name': 'Jane', 'age': 42}, ]} expected = {'members': [{'name': 'John'}, {'name': 'Jane'}]} assert_data(marshal(data, result), expected) # Should leave th original mask untouched assert_data(marshal(data, family_fields), data)
def post(self, username, project_name): """Добавляет проект. Обрабатывает POST запрос, добавляет проект в БД с указанными параметрами, также возвращает представление проекта с использованием модели :data:`project_model`. В случае, если проект с таким названием уже существует, то возвращает ошибку 422. :param str description: описание проекта, передается в теле запроса """ args = ProjectRoot.parser.parse_args() user = User.query.filter_by(username=username).first() project = Project(user_id=user.id, project_name=project_name, description=args['description']) db.session.add(project) try: db.session.commit() except IntegrityError: return {'message': 'Проект с таким названием уже существует.'}, 422 return marshal(project, project_model), 200
def put(self, tenant, personGUID): '''Update Person''' APIAdminCommon.verifySecurityOfAdminAPICall( appObj, request, tenant) content_raw = request.get_json() content = marshal(content_raw, getPersonModel(appObj)) requiredInPayload(content, ['guid', 'ObjectVersion']) if personGUID != content['guid']: raise BadRequest("Inconsistent guid") try: def someFn(connectionContext): return UpdatePerson(appObj, content['guid'], content['ObjectVersion'], connectionContext) personObj = appObj.objectStore.executeInsideTransaction(someFn) except customExceptionClass as err: if (err.id == 'personDosentExistException'): raise BadRequest(err.text) raise Exception('InternalServerError') except WrongObjectVersionExceptionClass as err: raise Conflict(str(err)) except: raise InternalServerError return personObj.getJSONRepresenation()
def test_marshal(self): model = OrderedDict([("foo", fields.Raw)]) marshal_dict = OrderedDict([("foo", "bar"), ("bat", "baz")]) output = marshal(marshal_dict, model) assert isinstance(output, dict) assert not isinstance(output, OrderedDict) assert output == {"foo": "bar"}
def test_marshal_handle_inheritance(self, app): api = Api(app) person = api.model('Person', { 'name': fields.String, 'age': fields.Integer, }) child = api.inherit('Child', person, { 'extra': fields.String, }) data = {'name': 'John Doe', 'age': 42, 'extra': 'extra'} values = ( ('name', { 'name': 'John Doe' }), ('name,extra', { 'name': 'John Doe', 'extra': 'extra' }), ('extra', { 'extra': 'extra' }), ) for value, expected in values: result = marshal(data, child, mask=value) assert result == expected
def test_marshal_nested_property_with_skip_none(self): class TestObject(object): @property def fee(self): return {"blah": "cool", "foe": None} model = OrderedDict([ ("foo", fields.Raw), ( "fee", fields.Nested( OrderedDict([ ("fye", fields.String), ("blah", fields.String), ("foe", fields.String), ]), skip_none=True, ), ), ]) obj = TestObject() obj.foo = "bar" obj.bat = "baz" output = marshal([obj], model) expected = [ OrderedDict([("foo", "bar"), ("fee", OrderedDict([("blah", "cool")]))]) ] assert output == expected
def test_marshal_tuple_with_skip_none(self): model = OrderedDict( [("foo", fields.Raw), ("bat", fields.Raw), ("qux", fields.Raw)] ) marshal_fields = OrderedDict([("foo", "bar"), ("bat", None)]) output = marshal((marshal_fields,), model, skip_none=True) assert output == [{"foo": "bar"}]
def put(self, tenantName): ''' Update user details ''' decodedJWTToken = verifySecurityOfAPICall(appObj, request, tenantName=tenantName) content_raw = request.get_json() content = marshal(content_raw, putNewShortUrlModel(appObj)) requiredInPayload(content, ["url"]) def dbfn(storeConnection): return appObj.shortUrlFunctions.putNewShortUrl( decodedJWTToken=decodedJWTToken, storeConnection=storeConnection, content=content, tenantName=tenantName) try: return appObj.objectStore.executeInsideTransaction(dbfn) except Logic.LogicException as e: raise BadRequest(str(e)) #raise e except RepositoryValidationException as e: raise BadRequest(str(e)) except WrongObjectVersionExceptionClass as err: raise Conflict(err)
def test_skip_none_presents_data(self): model = OrderedDict( [ ("foo", fields.Raw), ( "fee", fields.Nested( OrderedDict( [ ("fye", fields.String), ("blah", fields.String), ("foe", fields.String), ] ), skip_none=True, ), ), ] ) marshal_fields = OrderedDict( [("foo", "bar"), ("bat", "baz"), ("fee", {"blah": "cool", "foe": None})] ) output = marshal(marshal_fields, model) expected = OrderedDict( [("foo", "bar"), ("fee", OrderedDict([("blah", "cool")]))] ) assert output == expected
def delete(self, dataset_uuid, study_id=None, user=None): """ Delete a dataset from a study given its unique identifier """ prop_id_to_name = get_property_map(key="id", value="name") prop_name_to_id = reverse_map(prop_id_to_name) # Used for helper route using only dataset_uuid if study_id is None: study_id = find_study_id_from_lvl1_uuid("dataset", dataset_uuid, prop_name_to_id) if study_id is None: raise Exception( f"Dataset not found in any study (uuid = {dataset_uuid})") # 1. Get study data study = Study.objects().get(id=study_id) study_json = marshal(study, study_model) study_converter = FormatConverter(mapper=prop_id_to_name) study_converter.add_api_format(study_json["entries"]) # 2. Delete specific dataset datasets_entry = study_converter.get_entry_by_name("datasets") datasets_entry.value.delete_nested_entry("uuid", dataset_uuid) if len(datasets_entry.value.value) == 0: study_converter.remove_entries(prop_names=["datasets"]) # 3. Update study state, data and ulpoad on DB message = f"Deleted dataset" update_study(study, study_converter, api.payload, message, user) return {"message": message}
def get(self): """Retrieve all teams public information (no stages info)""" teams = list(Team.objects()) response = [] for team in teams: response.append(team.public_info) return marshal({'teams': response}, models.team_list), 200
def put(self, review_id): """Updates the star rating / text of a review.""" # Extract token was_successful, session_token = extract_token(request) response_object = {} if not was_successful: response_object["message"] = session_token return response_object, 400 # Check token validity user = get_user_by_session_token(session_token) if user is None: response_object["message"] = "Invalid token." return response_object, 400 # Create / validate Review object user_id = user.id review = get_review_by_id(review_id) if review is None: reviews_namespace.abort(404, f"Review {review_id} does not exist") elif user_id != review.user_id: reviews_namespace.abort(400, "Cannot edit other user's review") post_data = request.get_json() rating = post_data.get("rating") text = post_data.get("text") response_object = {} review = get_review_by_id(review_id) if not review: reviews_namespace.abort(404, f"Review {review_id} does not exist.") new_review = update_review(review, rating, text) response_object["message"] = f"Review {review.id} was updated!" print(new_review) return marshal(new_review, review_fields), 200
def get(self, team_id): """Retrieve team members as user objects""" try: team = Team.objects.get(id=ObjectId(team_id)) if current_user.email not in team.members: return marshal({"msg": f'You cannot access this team'}, models.error), 403 users = team.members_as_user_objects() return marshal({'users': users}, models.user_list), 200 except InvalidId: return marshal({"msg": f'{team_id} is not a valid ObjectID'}, models.error), 400 except DoesNotExist: return marshal( {"msg": f'Team with team ID {team_id} does not exist'}, models.error), 404
def post(self): """ Receive a receipt. """ data = marshal(api.payload, model_receipt, skip_none=True) order_id = data.get("order_id") extra = {"PAYMENT_ORDER_ID": order_id} logger.info("Payment receipt requested.", extra=extra) sandbox = parser_query.parse_args().get("sandbox") params = generate_liqpay_receipt_params(data, sandbox=sandbox) try: resp_json = liqpay_request_data(data=params, sandbox=sandbox) except (Timeout, ConnectionError): logger.warning("Liqpay api request failed.", extra=extra) abort(code=HTTPStatus.SERVICE_UNAVAILABLE) else: if not resp_json: raise LiqpayResponseErrorHTTPException() if resp_json.get("result") != "ok": raise LiqpayResponseErrorHTTPException( liqpay_err_description=resp_json.get("err_code")) return { "url_checkout": resp_json.get("url_checkout"), "order_id": params.get("order_id") }
def test_marshal_with_skip_none(self): model = OrderedDict([("foo", fields.Raw), ("bat", fields.Raw), ("qux", fields.Raw)]) marshal_dict = OrderedDict([("foo", "bar"), ("bat", None), ("qux", {})]) output = marshal(marshal_dict, model, skip_none=True) assert output == {"foo": "bar", "qux": {}}
def post(self): """Launches an interactive session.""" post_data = request.get_json() try: with TwoPhaseExecutor(db.session) as tpe: CreateInteractiveSession(tpe).transaction( post_data["project_uuid"], post_data["pipeline_uuid"], post_data["pipeline_path"], post_data["project_dir"], post_data["host_userdir"], ) except JupyterBuildInProgressException: return {"message": "JupyterBuildInProgress"}, 423 except Exception as e: current_app.logger.error(e) return {"message": str(e)}, 500 isess = models.InteractiveSession.query.filter_by( project_uuid=post_data["project_uuid"], pipeline_uuid=post_data["pipeline_uuid"], ).one_or_none() return marshal(isess.as_dict(), schema.session), 201
def test_marshal_wildcard_with_skip_none(self): wild = fields.Wildcard(fields.String) model = OrderedDict([("foo", fields.Raw), ("*", wild)]) marshal_dict = OrderedDict([("foo", None), ("bat", None), ("baz", "biz"), ("bar", None)]) output = marshal(marshal_dict, model, skip_none=True) assert output == {"baz": "biz"}
def get(self, record_id: UUID) -> Dict: """ Return a specific BRA with it's ID. """ with session_scope() as sess: global_rec = sess.query( BraRecord, func.lag(BraRecord.br_id).over( order_by=BraRecord.br_production_date, partition_by=BraRecord.br_massif, ).label("previous_bra_id"), func.lead(BraRecord.br_id).over( order_by=BraRecord.br_production_date, partition_by=BraRecord.br_massif, ).label("next_bra_id"), ).subquery() result_filtered = (sess.query(global_rec).filter( global_rec.c.br_id == record_id).first()) record_as_dict = result_filtered._asdict() record_as_dict["massif"] = (sess.query(Massif).filter( Massif.m_id == result_filtered.br_massif).first()) record_as_dict["risks"] = sess.query(Risk).filter( Risk.r_record_id == result_filtered.br_id) record_as_dict["snow_records"] = sess.query(SnowRecord).filter( SnowRecord.s_bra_record == result_filtered.br_id) record_as_dict["fresh_snow_records"] = sess.query( FreshSnowRecord).filter( FreshSnowRecord.fsr_bra_record == result_filtered.br_id) record_as_dict["weather_forecasts"] = sess.query( WeatherForecast).filter( WeatherForecast.wf_bra_record == result_filtered.br_id) record_as_dict["risk_forecasts"] = sess.query(RiskForecast).filter( RiskForecast.rf_bra_record == result_filtered.br_id) return marshal(record_as_dict, bra_model)
def post(self): """ Create Ad title min 3, max 100 body min 3, max 100 category {'id': id of category} media [{'path': 'path of media'}] max 5 :return: """ try: data = AdParser.parse_args() data['category'] = Category.query.get(data['category']['id']) if not data['category']: raise CustomException(detail='Category does not exist.') media = data.pop('media') data['user'] = g.user ad_item = Ad(**data).create() if media: for item in media: ad_item.media_set.append(Media(path=item['path'])) ad_item.save() return responses.SuccessResponse(marshal(ad_item, AdSchema), status=201).send() except CustomException as e: return responses.ErrorResponse(message=e.detail, status=e.status_code).send()