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()
