class AnalyticsDto:
api = Namespace("analytics", description="API for Analytics", ordered=True)
analytics_post = api.model(
"analytics",
{
"event_name":
fields.String(
required=True,
description="Name of the event for which data is recorded",
example="USER_LOGIN",
),
"user_data":
fields.Raw(
required=False,
description=
"A json object stored as string to pass all the related information",
example={"data": "something"}),
"device_info":
fields.Raw(
required=False,
description="A json object to store the device info",
example={
"device": "mobile",
"browser": "Chrome 80"
},
),
"network_info":
fields.Raw(
required=False,
description="A json object to store the network info",
example={"network": "3G"},
)
},
)
class WorkflowsDto:
api = Namespace("workflows", description="API for workflows", ordered=True)
workflows = api.model(
"workflows",
{
"en":
fields.Raw(
required=True,
description="English language details",
example={
"name": "Test workflow",
"description": "Some help text about workflow",
"description_image": ""
},
),
"ru":
fields.Raw(
required=True,
description='Language',
example={
"name": "Рабочий процесс тестирования",
"description": "Некоторая справка о рабочем процессе",
"description_image": ""
},
)
},
)
class GetHySDSIOType(Resource):
"""Get list of job queues and return as JSON."""
resp_model = hysds_io_ns.model(
'HySDS IO Response(JSON)', {
'success':
fields.Boolean(
required=True,
description="Boolean, whether the API was successful"),
'message':
fields.String(required=True,
description="message describing success or failure"),
'result':
fields.Raw(required=True, description="HySDS IO Object")
})
parser = hysds_io_ns.parser()
parser.add_argument('id', required=True, type=str, help="HySDS IO Type ID")
@hysds_io_ns.expect(parser)
@hysds_io_ns.marshal_with(resp_model)
def get(self):
"""Gets a HySDS-IO specification by ID"""
_id = request.form.get('id', request.args.get('id', None))
if _id is None:
return {'success': False, 'message': 'missing parameter: id'}, 400
hysds_io = mozart_es.get_by_id(index=HYSDS_IOS_INDEX,
id=_id,
ignore=404)
if hysds_io['found'] is False:
return {'success': False, 'message': ""}, 404
return {'success': True, 'message': "", 'result': hysds_io['_source']}
def test_nested_object(self, mocker):
foo = mocker.Mock()
bar = mocker.Mock()
bar.value = 42
foo.bar = bar
field = fields.Raw()
assert field.output("bar.value", foo) == 42
class GetContainerInfo(Resource):
"""Info a container"""
resp_model = container_ns.model(
'Container Info Response(JSON)', {
'success':
fields.Boolean(required=True,
description="if 'false', encountered exception; "
"otherwise no errors occurred"),
'message':
fields.String(required=True,
description="message describing success or failure"),
'result':
fields.Raw(required=True, description="Container Info")
})
parser = container_ns.parser()
parser.add_argument('id', required=True, type=str, help="Container ID")
@container_ns.expect(parser)
@container_ns.marshal_with(resp_model)
def get(self):
"""Get information on container by ID"""
_id = request.form.get('id', request.args.get('id', None))
container = mozart_es.get_by_id(index=CONTAINERS_INDEX,
id=_id,
ignore=404)
if container['found'] is False:
return {'success': False, 'message': ""}, 404
return {'success': True, 'message': "", 'result': container['_source']}
def get_restx_model() -> Model:
return Model(
"recipe_model",
{
"id": restxFields.Integer(readonly=True),
"time_created": restxFields.DateTime(readonly=True),
"time_updated": restxFields.DateTime(readonly=True),
"name": restxFields.String(),
"macros": restxFields.Raw(readonly=True),
"directions": restxFields.List(restxFields.String),
"image_url": restxFields.String(),
"recipe_url": restxFields.String(),
"thumbnail_url": restxFields.String(),
"author": restxFields.String(),
"servings": restxFields.Integer(),
"rating": restxFields.Integer(),
"prep_time": restxFields.Integer(),
"cook_time": restxFields.Integer(),
"source_name": restxFields.String(),
"diets": restxFields.List(restxFields.String),
"dish_types": restxFields.List(restxFields.String),
"tags": restxFields.List(restxFields.String),
"cuisines": restxFields.List(restxFields.String),
"ingredients": restxFields.List(restxFields.Raw),
},
)
class EdgeDetectorDto:
api = Namespace("detect_edges",
description="detect edges in image",
authorizations=authorizations)
image = api.model(
"image",
{
"image":
fields.String(required=True,
description="base64 encode content of the image")
},
)
# TODO should be possible to specify exact output type via fields.List
response = api.model(
"edge_detector_response",
{
"data":
fields.Raw(required=True,
description="coordinate of edges as a 4x2 list "
"of integers ")
},
)
headers = api.parser().add_argument("Authorization",
location="headers",
help="server to server token")
class BirdViewDto:
api = Namespace(
"bird_view",
description="make an bird view of the image using edges",
authorizations=authorizations,
)
# TODO should be possible to specify exact output type via fields.List in both
image = api.model(
"image_and_points",
{
"image":
fields.String(required=True,
description="base64 encode content of the image"),
"points":
fields.Raw(required=True,
description="coordinate of edges as a 4x2 list "
"of integers "),
},
)
response = api.model(
"bird_view_response",
{
"data":
fields.String(required=True,
description="base64 encode content of the "
"transformed image")
},
)
headers = api.parser().add_argument("Authorization",
location="headers",
help="server to server token")
class UserResponsesDto:
api = Namespace("user_responses", description="data filled by the user")
user_responses = api.inherit(
"user_responses", {
"user_id":
fields.Integer(
required=False,
description="User Id who has submitted the response",
example=2),
"user_workflow_id":
fields.Integer(
required=True,
description="User Id who has submitted the response",
example=2),
"workflow_details_id":
fields.Integer(
required=True,
description="User Id who has submitted the response",
example=2),
"response":
fields.Raw(required=True,
description="{'<question_id>:'<response>'}",
example={"<question_id>": "<response>"}),
"response_status":
fields.String(required=False,
description="user response status",
example="REVIEW")
})
class EvaluatedSkillsDto:
user_skill = api_namespace.model(
'evaluated_skill', {
'name':
fields.String(required=True, description='profile name'),
'scores':
fields.Raw(required=True,
description='map shaped { -skill_name- : -value-}')
})
skill_list = api_namespace.model(
'skill_list', {
'skills':
fields.List(fields.Nested(user_skill),
required=True,
description='list of profiles')
})
@staticmethod
def build_json_from_skills(evaluated_skills):
response = []
skill_data = evaluated_skills.get_skills_data()
for skill in skill_data:
response.append(skill_data[skill])
return {'skills': response}
def getLoginPostDataModel(appObj):
return appObj.flastRestPlusAPIObject.model(
'LoginPostData', {
'authProviderGUID':
fields.String(
default=None,
description='Unique identifier of AuthProvider to log in with',
required=True),
'credentialJSON':
fields.Raw(
description=
'JSON structure required depends on the Auth Provider type',
required=True),
'UserID':
fields.String(
default=None,
description=
'If a person has access to mutiple Users then they specify the UserID of the one they need to login with'
),
'ticket':
fields.String(
default=None,
description=
'If a user has a ticket to grant them extra roles on the tenant'
)
})
class GetJobInfo(Resource):
"""Get info of job IDs."""
resp_model = job_ns.model('Job Info Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false' encountered exception; "
"otherwise no errors occurred"),
'message': fields.String(required=True, description="message describing success or failure"),
'result': fields.Raw(required=True, description="Job Info Object")
})
parser = job_ns.parser()
parser.add_argument('id', type=str, required=True, help="Job ID")
@job_ns.expect(parser)
@job_ns.marshal_with(resp_model)
def get(self):
"""Get complete info for submitted job based on id"""
_id = request.form.get('id', request.args.get('id', None))
if _id is None:
return {
'success': False,
'message': 'id must be supplied (as query param or url param)'
}, 400
info = mozart_es.get_by_id(index=JOB_STATUS_INDEX, id=_id, ignore=404)
if info['found'] is False:
return {
'success': False,
'message': 'job info not found: %s' % _id
}, 404
return {
'success': True,
'message': "",
'result': info['_source']
}
class GetQueueNames(Resource):
"""Get list of job queues and return as JSON."""
resp_model = queue_ns.model('Queue Listing Response(JSON)', {
'success': fields.Boolean(required=True, description="if 'false' encountered exception; "
"otherwise no errors occurred"),
'message': fields.String(required=True, description="message describing success or failure"),
'result': fields.Raw(required=True, description="queue response")
})
parser = queue_ns.parser()
parser.add_argument('id', type=str, help="Job Type Specification ID")
@queue_ns.expect(parser)
@queue_ns.marshal_with(resp_model)
def get(self):
"""Gets a listing of non-celery queues handling jobs."""
try:
ident = request.form.get('id', request.args.get('id', None))
queues = mozart.lib.queue_utils.get_queue_names(ident)
app.logger.warn("Queues: " + str(queues))
except Exception as e:
message = "Failed to list job queues. {0}:{1}".format(type(e), str(e))
app.logger.warning(message)
app.logger.warning(traceback.format_exc(e))
return {'success': False, 'message': message}, 500
return {
'success': True,
'message': "",
'result': queues
}
def _translate_attribute(self, name, attr, namespace):
logger.debug('Translating {}.{}'.format(self.name, name))
field = None
if isinstance(attr, attributes.MapAttribute):
if attr.__class__ == attributes.MapAttribute:
map_name = name.title()
field = PynamoMapAttribute(map_name)
else:
map_name = attr.__class__.__name__
field = self._get_or_create_nested(map_name, attr, namespace)
elif isinstance(attr, self.MAPMETA):
field = self._get_or_create_nested(name, attr, namespace)
elif isinstance(attr, attributes.ListAttribute):
if attr.element_type:
element_type = self._translate_attribute(attr.element_type.__name__, attr.element_type, namespace)
else:
element_type = fields.String()
field = fields.List(element_type)
else:
for p_attr, r_field in self.TYPEMAP.items():
if isinstance(attr, p_attr):
field = r_field
break
else:
logger.warn('Unhandled attribute {} mapped as Raw'.format(attr))
field = fields.Raw()
logger.debug('Translated {}.{}={} as {}'.format(self.name, name, attr.__class__, field.__class__))
return field
def getAPIKeyModel(appObj):
return appObj.flastRestPlusAPIObject.model('APIKeyModel', {
'id': fields.String(default='DEFAULT', description='Unique identifier of APIKey'),
'tenantName': fields.String(default='DEFAULT', description='Name of the Tenant this APIKey associated with'),
'createdByUserID': fields.String(default='DEFAULT', description='UserGUID of user who created this ticket'),
'restrictedRoles': fields.List(fields.String(default=None,description='If not an empty list a subset of the users roles to be inherited by this APIKey'),required=True),
'externalData': fields.Raw(description='Any other data supplied during apikey creation', required=True),
RepositoryObjBaseClass.getMetadataElementKey(): fields.Nested(RepositoryObjBaseClass.getMetadataModel(appObj, flaskrestplusfields=fields))
})
def test_with_partial_attribute(self, mocker):
def f(x, suffix):
return '{0}-{1}'.format(x.value, suffix)
obj = mocker.Mock()
obj.value = 42
p = partial(f, suffix='whatever')
field = fields.Raw(attribute=p)
assert field.output('foo', obj) == '42-whatever'
def test_with_partial_attribute(self, mocker):
def f(x, suffix):
return "{0}-{1}".format(x.value, suffix)
obj = mocker.Mock()
obj.value = 42
p = partial(f, suffix="whatever")
field = fields.Raw(attribute=p)
assert field.output("foo", obj) == "42-whatever"
class MapsRoute(Resource):
success_model = ns.model('Maps service route response - success', {})
error_model = ns.model('Maps service route response - error',
{'error': fields.Raw({})})
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.date_now = datetime.datetime.utcnow() + datetime.timedelta(
hours=1)
@ns.response(200, 'OK', success_model)
@ns.response(400, 'Error', error_model)
@ns.doc(
description=
'Get a route from origin to destination with a optional arrival time.')
def get(self):
if ('origin' not in request.args or 'destination'
not in request.args) or (not request.args.get('origin') or
not request.args.get('destination')):
return make_response(
{
'error':
'Not all required arguments specified (origin, destination)'
},
400,
)
origin = request.args.get('origin')
destination = request.args.get('destination')
arrival_time = request.args.get('arrival_time')
gmaps = googlemaps.Client(key=os.getenv('API_KEY'))
# Request directions
if 'arrival_time' not in request.args or not request.args.get(
'arrival_time'):
print(self.date_now)
directions_result = gmaps.directions(
origin,
destination,
# mode='transit',
# departure_time=self.date_now,
units='metric',
)
else:
directions_result = gmaps.directions(
origin,
destination,
arrival_time=arrival_time,
# mode='transit',
units='metric',
)
return make_response(jsonify(directions_result), 200)
def getAuthProviderModel(appObj):
return appObj.flastRestPlusAPIObject.model(
'AuthProviderInfo', {
'guid':
fields.String(default=None,
description='Unique identifier of AuthProvider'),
'Type':
fields.String(default='internal',
description='Authorization provider type'),
'AllowUserCreation':
fields.Boolean(
default=False,
description=
'Allow unknown logins to create new users. (Must be set to true at this level AND Tenant level to work)'
),
'AllowLink':
fields.Boolean(
default=None,
description='Allow user to add this as a secondary auth method'
),
'AllowUnlink':
fields.Boolean(
default=None,
description=
'Allow user to remove this auth method (As long as they have others availiable)'
),
'LinkText':
fields.String(
default=None,
description=
'Text to show on link button in Security settings UI'),
'MenuText':
fields.String(
default='click here',
description='Item text used in login method selection screen'),
'IconLink':
fields.String(
default=None,
description='Image link used in login method selection screen'
),
'ConfigJSON':
fields.String(
default=None,
description='Extra configuration required per auth type'),
'StaticlyLoadedData':
fields.Raw(description='Other data loaded for this auth type'),
'saltForPasswordHashing':
fields.String(
default=None,
description=
'Salt that can be used for password hashing (Depends on auth method)'
)
})
def get_restx_model() -> Model:
return Model(
"User Model",
{
"id": restxFields.Integer(),
"time_created": restxFields.DateTime(),
"time_updated": restxFields.DateTime(),
"username": restxFields.String(),
"email": restxFields.String(),
"active": restxFields.Boolean(),
"first_name": restxFields.String(),
"last_name": restxFields.String(),
"birthday": restxFields.Date(),
"height_inches": restxFields.Float(),
"weight_lbs": restxFields.Float(),
"gender": restxFields.String(),
"household": restxFields.Raw(),
"household_id": restxFields.Integer(),
"roles": restxFields.List(restxFields.Raw()),
},
)
def get_models_parsers(api):
get_file_parser = reqparse.RequestParser()
get_file_parser.add_argument('FileName',
type=str,
location='headers',
required=True)
post_file_model = api.model('admin_update_schema_fields', {
'FileData': fields.Raw(required=True),
})
return get_file_parser, post_file_model
class EmployeeApi:
api = Namespace('employee', description='Employee of the company')
employee = api.model(
'employee', {
'id':
fields.Integer(required=True, description='Id of the employee'),
'first':
fields.String(required=True,
description='First name of the person'),
'last':
fields.String(required=True, description='Surname of the person'),
'department':
fields.Raw(
description=
'Id or object of the department where the employee belongs'),
'office':
fields.Raw(
description=
'Id or object of the office where the employee belongs'),
'manager':
fields.Raw(
description='Id or object of the manager of the employee')
})
def getLoginResponseModel(appObj):
jwtTokenModel = appObj.flastRestPlusAPIObject.model(
'JWTTokenInfo', {
'JWTToken':
fields.String(description='JWTToken'),
'TokenExpiry':
fields.DateTime(dt_format=u'iso8601',
description='Time the JWTToken can be used until')
})
refreshTokenModel = appObj.flastRestPlusAPIObject.model(
'RefreshTokenInfo', {
'token':
fields.String(description='Refresh Token'),
'TokenExpiry':
fields.DateTime(
dt_format=u'iso8601',
description='Time the Refresh token can be used until')
})
return appObj.flastRestPlusAPIObject.model(
'LoginResponseData', {
'possibleUsers':
fields.List(fields.Nested(getUserModel(appObj))),
'jwtData':
fields.Nested(jwtTokenModel, skip_none=True),
'refresh':
fields.Nested(refreshTokenModel, skip_none=True),
'userGuid':
fields.String(
description=
'Unique identifier of user to be used by the application'),
'authedPersonGuid':
fields.String(
description='Unique identifier of person for use with Auth APIs'
),
'ThisTenantRoles':
fields.List(
fields.String(
description=
'Role the user has been assigned for this tenant')),
'known_as':
fields.String(description='User friendly identifier for username'),
'other_data':
fields.Raw(description='Any other data supplied by auth provider',
required=True),
'currentlyUsedAuthProviderGuid':
fields.String(
description='GUID of auth provider used to login with'),
'currentlyUsedAuthKey':
fields.String(description='Key of auth used to login with')
})
class TestDto:
api = Namespace('test', description='test management operations')
test_cases = api.model(
'test_cases', {
'test_cases': fields.List(fields.String()),
'test_suite': fields.String(),
})
test_suite = api.model(
'test_suite', {
'id': fields.String(),
'test_suite': fields.String(),
'path': fields.String(),
'test_cases': fields.List(fields.String()),
'variables': fields.Raw(),
'author': fields.String()
})
def getRegisterPostDataModel(appObj):
return appObj.flastRestPlusAPIObject.model(
'RegisterPostData', {
'authProviderGUID':
fields.String(
default='DEFAULT',
description='Unique identifier of AuthProvider to log in with',
required=True),
'credentialJSON':
fields.Raw(
description=
'JSON structure required depends on the Auth Provider type',
required=True),
'ticket':
fields.String(default='DEFAULT',
description='If a user has a ticket to grant access')
})
def getCreateAuthModel(appObj):
return appObj.flastRestPlusAPIObject.model(
'CreateAuthInfo', {
'personGUID':
fields.String(default='DEFAULT',
description='Unique identifier of Person',
required=True),
'tenantName':
fields.String(description='Name of Tenant'),
'authProviderGUID':
fields.String(default='DEFAULT',
description='Unique identifier of Person',
required=True),
'credentialJSON':
fields.Raw(
description=
'JSON structure required depends on the Auth Provider type',
required=True),
})
def getServerInfoModel(appObj):
serverInfoServerModel = appObj.flastRestPlusAPIObject.model(
'mainAPI', {
'Version':
fields.String(
default='DEFAULT',
description='Version of container running on server'),
'APIAPP_APIDOCSURL':
fields.String(default='',
description='Base endpoint for EBO docs'),
'APIAPP_FRONTENDURL':
fields.String(default='',
description='Base endpoint for frontend of app')
})
return appObj.flastRestPlusAPIObject.model(
'ServerInfo', {
'Server': fields.Nested(serverInfoServerModel),
'Derived': fields.Raw(required=False)
})
class PaymentRequest:
"""
Payment request model.
"""
api = Namespace('payment', description='payment related operations')
body = api.model(
'payment', {
'source_address':
fields.String(required=True,
min_length=25,
max_length=36,
description='source address'),
'outputs':
fields.Raw(required=True,
description='outputs to send transaction'),
'fee_kb':
fields.Integer(required=True,
unsigned=True,
description='the fee value in kb\'s'),
})
class GetJobSpecType(Resource):
"""Get list of job queues and return as JSON."""
resp_model = job_spec_ns.model(
'Job Type Specification Response(JSON)', {
'success':
fields.Boolean(required=True,
description="if 'false', encountered exception; "
"otherwise no errors occurred"),
'message':
fields.String(required=True,
description="message describing success or failure"),
'result':
fields.Raw(required=True, description="Job Type Specification")
})
parser = job_spec_ns.parser()
parser.add_argument('id', required=True, type=str, help="Job Type ID")
@job_spec_ns.expect(parser)
@job_spec_ns.marshal_with(resp_model)
def get(self):
"""Gets a Job Type specification object for the given ID."""
_id = request.form.get('id', request.args.get('id', None))
if _id is None:
return {'success': False, 'message': 'missing parameter: id'}, 400
job_spec = mozart_es.get_by_id(index=JOB_SPECS_INDEX,
id=_id,
ignore=404)
if job_spec['found'] is False:
app.logger.error('job_spec not found %s' % _id)
return {
'success': False,
'message': 'Failed to retrieve job_spec: %s' % _id
}, 404
return {
'success': True,
'message': "job spec for %s" % _id,
'result': job_spec['_source']
}
def getUserModel(appObj):
TenantRoleModel = appObj.flastRestPlusAPIObject.model(
'TenantRoleModel', {
'TenantName':
fields.String(default='DEFAULT', description='Tenant Name'),
'ThisTenantRoles':
fields.List(
fields.String(
description=
'Role the user has been assigned for this tenant')),
})
return appObj.flastRestPlusAPIObject.model(
'UserInfo', {
'UserID':
fields.String(default='DEFAULT',
description='Unique identifier of User'),
'known_as':
fields.String(description='User friendly identifier for username'),
'TenantRoles':
fields.List(fields.Nested(TenantRoleModel)),
'other_data':
fields.Raw(description='Any other data supplied by auth provider',
required=True),
'associatedPersonGUIDs':
fields.List(
fields.String(
description='GUIDs of associated user accounts')),
'ObjectVersion':
fields.String(
default='DEFAULT',
description=
'Obect version required to sucessfully preform updates'),
'creationDateTime':
fields.DateTime(dt_format=u'iso8601',
description='Datetime user was created'),
'lastUpdateDateTime':
fields.DateTime(dt_format=u'iso8601',
description='Datetime user was lastupdated')
})
