def test_marshal_nested_with_skip_none(self):
model = OrderedDict([
('foo', fields.Raw),
('fee', fields.Nested(
OrderedDict([
('fye', fields.String)
]), skip_none=True))
])
marshal_fields = OrderedDict([('foo', 'bar'),
('bat', 'baz'),
('fee', None)])
output = marshal(marshal_fields, model, skip_none=True)
expected = OrderedDict([('foo', 'bar')])
assert output == expected
def getTicketDisableBatchProcessModel(appObj):
subModel = appObj.flastRestPlusAPIObject.model(
'TicketDisableBatchProcessSubModel', {
'ticketGUID':
fields.String(default='DEFAULT',
description='GUID for this ticket'),
'objectVersion':
fields.String(default='DEFAULT', description='Object version'),
})
return appObj.flastRestPlusAPIObject.model(
'TicketDisableBatchProcessModel', {
'tickets': fields.List(fields.Nested(subModel)),
})
class BalanceRetrieve(Resource):
balance_model = api.model('Balance Response',
balance_retrieve_response_model)
balance_wrapper = {"data": fields.List(fields.Nested(balance_model))}
http_balance_response = api.inherit('HTTP Balance Response',
httpResponseBase_response,
balance_wrapper)
@jwt_required
@api.marshal_with(http_balance_response)
def get(self):
uuid = get_jwt_identity()['uuid']
return HttpResponse(data=retrieveBalance(uuid)), 200
def getLoginAPITicketModel(appObj):
return appObj.flastRestPlusAPIObject.model(
'LoginAPITicketModel', {
'ticketType':
fields.Nested(apiSharedModels.getTicketTypeModel(appObj)),
'isUsable':
fields.String(
default='INVALID',
description='Is the ticket usable (INVALID, EXPIRED or USABLE)'
),
'expiry':
fields.DateTime(dt_format=u'iso8601',
description='Datetime ticket will expire')
})
def test_marshal_wildcard_list(self):
wild = fields.Wildcard(fields.List(fields.String))
wildcard_fields = OrderedDict([('*', wild)])
model = OrderedDict([('preview', fields.Nested(wildcard_fields))])
sub_dict = OrderedDict([
('1:1', [1, 2, 3]),
('16:9', [4, 5, 6]),
('9:16', [7, 8, 9])
])
marshal_dict = OrderedDict([('preview', sub_dict)])
output = marshal(marshal_dict, model)
assert output == {'preview': {'9:16': ['7', '8', '9'],
'16:9': ['4', '5', '6'],
'1:1': ['1', '2', '3']}}
def test_marshal_list_of_nesteds(self):
model = OrderedDict([
('foo', fields.Raw),
('fee', fields.List(fields.Nested({
'fye': fields.String
})))
])
marshal_fields = OrderedDict([('foo', 'bar'),
('bat', 'baz'),
('fee', {'fye': 'fum'})])
output = marshal(marshal_fields, model)
expected = OrderedDict([('foo', 'bar'),
('fee', [OrderedDict([('fye', 'fum')])])])
assert output == expected
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"},
}
}
class AuthDto:
api = Namespace("Authentication",
description="Authenticate and receive tokens.")
user_obj = api.model(
"User object",
{
"id": fields.String,
"first_name": fields.String,
"last_name": fields.String,
"full_name": fields.String,
"date_joined": fields.DateTime,
"email": fields.String,
"is_superuser": fields.Boolean,
"is_active": fields.Boolean,
"is_staff": fields.Boolean,
},
)
auth_login = api.model(
"Login data",
{
"email": fields.String(required=True),
"password": fields.String(required=True),
},
)
auth_refresh = api.parser()
auth_refresh.add_argument('Authorization', type=str, location='headers')
auth_success = api.model(
"Auth success response",
{
"status": fields.Boolean,
"message": fields.String,
"access_token": fields.String,
"refresh_token": fields.String,
"user": fields.Nested(user_obj),
},
)
refresh_success = api.model(
"Refresh success response",
{
"status": fields.Boolean,
"message": fields.String,
"access_token": fields.String,
},
)
class HarvestingFormDto:
api = Namespace('harvesting_form',
description='harvesting_form related operations')
harvesting_form = api.model('harvesting_form', {
'date': fields.Date(required=True, description='partial form'),
'time': fields.DateTime(required=True, description='partial form'),
'plot': fields.Integer(required=True, description='partial form'),
'quantity': fields.Integer(required=True, description='partial form'),
'harvest_quantity': fields.String(required=True, description='partial form'),
'note': fields.String(required=True, description='partial form'),
})
harvesting_form_field_based = api.model('harvesting_form_field_based', {
'harvesting_form': fields.Nested(harvesting_form, required=True),
'field_required': fields.String(default=None, required=True, description="fields to make predictions on"), })
class IssueFormDto:
api = Namespace('issue_form',
description='issue_form related operations')
issue_form = api.model('issue_form', {
'date': fields.Date(required=True, description='partial form'),
'time': fields.DateTime(required=True, description='partial form'),
'plot': fields.Integer(required=True, description='partial form'),
'issue_type': fields.Integer(required=True, description='partial form'),
'description': fields.String(required=True, description='partial form'),
'note': fields.String(required=True, description='partial form'),
})
issue_form_field_based = api.model('issue_form_field_based', {
'issue_form': fields.Nested(issue_form, required=True),
'field_required': fields.String(default=None, required=True, description="fields to make predictions on"), })
class MapDto:
api = Namespace('maps', description='Map object related operations')
coordinate_model = api.model(
'Coordinate', {
'x': fields.Integer(required=True, description='x coordinate'),
'y': fields.Integer(required=True, description='y coordinate')
})
map_model = api.model(
'Map',
{
'_id':
ObjectIDField(description='Map ID'),
'height':
fields.Integer(required=True, description='Map height'),
'width':
fields.Integer(required=True, description='Map width'),
'tank1_start':
fields.Nested(coordinate_model,
required=True,
description='Starting position for the first tank'),
'tank2_start':
fields.Nested(coordinate_model,
required=True,
description='Starting position for the second tank')
# 'obstacles': fields.List(
# fields.List(
# fields.Integer(),
# # min_items=2,
# # max_items=2,
# description='An obstacle is a list of integers that represent X and Y coordinates on the map'
# ),
# description='The list of obstacles'
# ),
})
def test_marshal_list_of_nesteds(self):
model = OrderedDict(
[
("foo", fields.Raw),
("fee", fields.List(fields.Nested({"fye": fields.String}))),
]
)
marshal_fields = OrderedDict(
[("foo", "bar"), ("bat", "baz"), ("fee", {"fye": "fum"})]
)
output = marshal(marshal_fields, model)
expected = OrderedDict(
[("foo", "bar"), ("fee", [OrderedDict([("fye", "fum")])])]
)
assert output == expected
def test_marshal_nested_with_null(self):
model = OrderedDict([
('foo', fields.Raw),
('fee', fields.Nested(
OrderedDict([
('fye', fields.String),
('blah', fields.String)
]), allow_null=True))
])
marshal_fields = OrderedDict([('foo', 'bar'),
('bat', 'baz'),
('fee', None)])
output = marshal(marshal_fields, model)
expected = OrderedDict([('foo', 'bar'), ('fee', None)])
assert output == expected
def get_api_dict(api: Api,
depth: int = 0,
name: str = 'ParsedDocument') -> Model:
return api.model(
name, {
'content':
fields.Nested(DocumentContent.get_api_dict(api),
description='Document content structure'),
'metadata':
fields.Nested(DocumentMetadata.get_api_dict(api),
allow_null=False,
skip_none=True,
description='Document meta information'),
'version':
fields.String(
description=
'the version of the program that parsed this document',
example="2020.07.11"),
'warnings':
fields.List(
fields.String(
description='list of warnings and possible errors',
example="DOCX: seems that document corrupted")),
'attachments':
fields.List(fields.Nested(
api.model('others_ParsedDocument', {})),
description='structure of attachments',
required=False) if depth
== get_config()['recursion_deep_attachments'] else fields.List(
fields.Nested(ParsedDocument.get_api_dict(
api,
depth=depth + 1,
name='refParsedDocument' + str(depth)),
description='Attachment structure',
required=False))
})
class BrandDto:
api = Namespace('brand', description='brand related operations')
brand = api.model('brand', {
'id': fields.Integer(required=False, description='brand id'),
'name': fields.String(required=True, description='brand name'),
'products': fields.List(fields.Nested(ProductDto.product))
})
post_brand = api.model('brand', {
'name': fields.String(required=True, description='brand name'),
'products': fields.List(fields.Integer(description='Product identifier')),
})
put_brand = api.model('brand', {
'name': fields.String(required=False, description='brand name'),
'products': fields.List(fields.Integer(description='Product identifier')),
})
def test_marshal_wildcard_list(self):
wild = fields.Wildcard(fields.List(fields.String))
wildcard_fields = OrderedDict([("*", wild)])
model = OrderedDict([("preview", fields.Nested(wildcard_fields))])
sub_dict = OrderedDict([("1:1", [1, 2, 3]), ("16:9", [4, 5, 6]),
("9:16", [7, 8, 9])])
marshal_dict = OrderedDict([("preview", sub_dict)])
output = marshal(marshal_dict, model)
assert output == {
"preview": {
"9:16": ["7", "8", "9"],
"16:9": ["4", "5", "6"],
"1:1": ["1", "2", "3"],
}
}
def test_marshal_nested_with_skip_none(self):
model = OrderedDict([
("foo", fields.Raw),
(
"fee",
fields.Nested(OrderedDict([("fye", fields.String)]),
skip_none=True,
allow_null=True),
),
(
"bee",
fields.Nested(OrderedDict([("bye", fields.String)]),
skip_none=True),
),
])
marshal_fields = OrderedDict([
("foo", "bar"),
("bat", "baz"),
("fee", None),
("bee", {}),
])
output = marshal(marshal_fields, model, skip_none=True)
expected = OrderedDict([("foo", "bar"), ("bee", {})])
assert output == expected
class InstagramDTO:
api = Namespace('instagram', description='instagram related operations')
comment = api.model(
'InstagramComment', {
'id': fields.String,
'text': fields.String,
'created_at': fields.DateTime,
'username': fields.String,
'sentiment': fields.String
})
response = api.model(
'InstagramResponse', {
'comments': fields.List(fields.Nested(comment)),
'has_next_page': fields.Boolean,
'new_end_cursor': fields.String
})
class User(Resource):
res_userinfo = UserNs.impl.model(
'user_list', {
'status': fields.String(required=True, description='status'),
'message': fields.String(required=True, description='status'),
'data': fields.Nested(UserNs.userinfo)
})
@UserNs.impl.doc('get a user')
@UserNs.impl.marshal_with(res_userinfo)
def get(self, public_id):
user = get_a_user(public_id)
if not user:
UserNs.impl.abort(404, 'cant find user', status='fail')
else:
return {'status': 'success', 'message': 'list', 'data': user}
class AuthDto:
api = Namespace("auth", description="authentication related operations")
users_payload = UsersDto.users_payload
auth_response = api.inherit(
"AuthenticationResponse",
UsersDto.user_response,
{"auth_token": fields.String(description="authentication token")},
)
logout_response = api.inherit(
"LogoutResponse",
BaseDto.response,
{"message": fields.String(description="success or failure message")},
)
user = UsersDto.user
user_status_response = api.inherit("UserStatusResponse", BaseDto.response,
{"data": fields.Nested(user)})
class TaskDto():
api = Namespace('tasks', description='Task api information')
model_content = api.model(
'content', {
'text': fields.String(required=True, description='text value'),
'created_on': fields.Date(description='YYYY-MM-DD'),
'updated_on': fields.Date(description='YYYY-MM-DD'),
})
model_nest = fields.Nested(model_content)
model_wild = fields.Wildcard(model_nest)
task = api.model('task', {'*': model_wild})
class PatientsLists(Resource):
model = namespace.model(
'PatientsData', {
'patients':
fields.List(required=True,
cls_or_instance=fields.Nested(patient_out)),
})
@namespace.response(code=200, model=model, description='')
@namespace.response(
code=500,
model=failed_response,
description='Unexpected error, see contents for details.')
def get(self):
patients = PatientRepository.get_all_active()
result = []
for pa in patients:
result.append(_patient_model_to_dto(pa))
return result
@namespace.doc(body=patient_in_post_put)
@namespace.response(code=200, model=patient_out, description='')
@namespace.response(code=400, model=failed_response, description='')
@namespace.response(code=401, model=failed_response, description='')
@namespace.response(code=500, model=failed_response, description='')
def post(self):
post_data = request.get_json()
pa = PatientModel(first_name=post_data['first_name'],
last_name=post_data['last_name'],
date_of_birth=_parse_datetime(
post_data['date_of_birth']),
height=float(post_data['height']),
weight=float(post_data['weight']),
sex=post_data['sex'],
active=True,
heparin=False,
insulin=False,
target_aptt_low=None,
target_aptt_high=None,
solution_heparin_iu=25000,
solution_ml=500,
tddi=None,
target_glycemia=None,
other_params={})
return _update_patient(pa, post_data, True)
def getTicketWithCaculatedFieldsModel(appObj):
return appObj.flastRestPlusAPIObject.model(
'TicketTypeWithCaculated',
{
'id':
fields.String(
default='DEFAULT',
description='Unique identifier of Ticket - used in URL'),
'typeGUID':
fields.String(
default='DEFAULT',
description='Unique identifier of Ticket - used in URL'),
'expiry':
fields.DateTime(dt_format=u'iso8601',
description='Datetime ticket will expire'),
'foreignKey':
fields.String(
default='DEFAULT',
description='Unique identifier of Ticket - used in URL'),
'usedDate':
fields.DateTime(
dt_format=u'iso8601',
description='Datetime ticket was used or none if it wasn\'t'),
'useWithUserID':
fields.String(
default=None,
description='Unique identifier of Ticket - used in URL'),
'reissueRequestedDate':
fields.DateTime(
dt_format=u'iso8601',
description='Datetime ticket was reissueRequestedDate'),
'reissuedTicketID':
fields.String(
default=None,
description='Unique identifier of Ticket - used in URL'),
'disabled':
fields.Boolean(default=False,
description='Has this ticket been disabled'),
RepositoryObjBaseClass.getMetadataElementKey():
fields.Nested(
RepositoryObjBaseClass.getMetadataModel(
appObj, flaskrestplusfields=fields)),
# Extra below
'usableState':
fields.String(default='DEFAULT',
description='Usable state of this ticket')
})
class InventoryDto:
api = Namespace('inventory', description='inventory related operations')
inventory = api.model('inventory', {
'id': fields.Integer(required=False, description='inventory id'),
'name': fields.String(required=True, description='inventory name'),
'store_id': fields.Integer(required=True, description='store to which inventory belongs'),
'products': fields.List(fields.Nested(ProductDto.product))
})
post_inventory = api.model('inventory', {
'store_id': fields.Integer(required=True, description='store to which inventory belongs'),
'name': fields.String(required=True, description='brand name'),
'products': fields.List(fields.Integer(description="Product identifiers"))
})
put_inventory = api.model('inventory', {
'name': fields.String(required=False, description='brand name'),
'products': fields.List(fields.Integer(description="Product identifiers"))
})
def test_marshal_nested_ordered(self):
model = OrderedDict(
[("foo", fields.Raw), ("fee", fields.Nested({"fye": fields.String,}))]
)
marshal_fields = {
"foo": "bar",
"bat": "baz",
"fee": {"fye": "fum"},
}
expected = OrderedDict([("foo", "bar"), ("fee", OrderedDict([("fye", "fum")]))])
output = marshal(marshal_fields, model, ordered=True)
assert isinstance(output, OrderedDict)
assert output == expected
assert isinstance(output["fee"], OrderedDict)
class AttachmentModel(ModelCreator):
id = create_id_field(
required=True,
description="Attachment ID in database",
)
author = fields.Nested(full_employee)
post = create_id_field(
required=True, description="ID of Post that contains this attachment")
filename = fields.String(required=True,
description="Name of an attachment",
example="gravity_gun_firmware.bin",
min_length=1)
size = fields.Integer(required=True,
description="Size of attachment (in bytes)",
example=256256,
min=0,
max=MAX_FILE_SIZE)
def test_marshal_nested_with_null(self):
model = OrderedDict([
("foo", fields.Raw),
(
"fee",
fields.Nested(
OrderedDict([("fye", fields.String),
("blah", fields.String)]),
allow_null=True,
),
),
])
marshal_fields = OrderedDict([("foo", "bar"), ("bat", "baz"),
("fee", None)])
output = marshal(marshal_fields, model)
expected = OrderedDict([("foo", "bar"), ("fee", None)])
assert output == expected
def getCreateTicketTypeModel(appObj):
return appObj.flastRestPlusAPIObject.model(
'CreateTicketType', {
'tenantName':
fields.String(default='DEFAULT',
description='Tenant name for this ticket type'),
'ticketTypeName':
fields.String(default='DEFAULT',
description='Name displayed on admin screent'),
'description':
fields.String(default='DEFAULT',
description='Description of ticket type'),
'enabled':
fields.Boolean(
default=False,
description='Can the ticket type currently be used'),
'welcomeMessage':
fields.Nested(getCreateTicketTypeModel_welcomeMessage(appObj),
skip_none=True),
'allowUserCreation':
fields.Boolean(
default=False,
description=
'Allow unknown logins to create new users when using this ticket.'
),
'issueDuration':
fields.Integer(
default='DEFAULT',
description='Hours to issue ticket for on creation'),
'roles':
fields.List(
fields.String(
default='DEFAULT',
description='List of roles this tickert type will assign')
),
'postUseURL':
fields.String(
default='DEFAULT',
description='URL to send user to after ticket is used'),
'postInvalidURL':
fields.String(
default='DEFAULT',
description=
'URL to send user to after invalid or request validaiton')
})
class HDDSMARTPredictionDto:
api = Namespace('HDDSMARTPrediction', description='HDDSMARTPrediction related operations')
smart_prediction = api.model(
'SMARTPrediction',
{
'track_dev_id': fields.String(30, description='tracked device id', example="0"),
'timestamp': fields.String(30, description='Prediction Timestamp', example="2019-12-01 14:20:30"),
'model': fields.String(required=True, description='HDD model', example="XYZ"),
'serial_number': fields.String(required=True, description='HDD serial number', example="HD00"),
'capacity_bytes': fields.Integer(example=1000000000),
'failure': fields.Integer,
'prediction': fields.Float
}
)
prediction_list_example = {'prediction_list': [
{
"track_dev_id": "0",
"timestamp": "2019-12-01 14:20:30",
"model": "XYZ",
"serial_number": "HD00",
"capacity_bytes": 1000000000,
"failure": 0,
"prediction": 0
},
{
"track_dev_id": "1",
"timestamp": "2019-12-01 14:20:40",
"model": "UVT",
"serial_number": "00DH",
"capacity_bytes": 1000000001,
"failure": 1,
"prediction": 1
}
]
}
smart_prediction_list = api.model(
'SMARTPredictionList',
{
'prediction_list': fields.List(fields.Nested(smart_prediction))
}
)
class ApplicationFormDto:
api = Namespace('application_form',
description='application_form related operations')
application_form = api.model('application_form', {
'date': fields.Date(required=True, description='partial form'),
'time': fields.DateTime(required=True, description='partial form'),
'plot': fields.Integer(required=True, description='partial form'),
'product': fields.String(required=True, description='partial form'),
'quantity': fields.Integer(required=True, description='partial form'),
'dose': fields.Float(required=True, description='partial form'),
'machine': fields.String(required=True, description='partial form'),
'note': fields.String(required=True, description='partial form'),
})
application_form_field_based = api.model('application_form_field_based', {
'application_form': fields.Nested(application_form, required=True),
'field_required': fields.String(default=None, required=True, description="fields to make predictions on"), })
