class CollectionClear(Resource):
@api.doc(responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@api.expect(api.schema_model('DocumentClear',
get_dict(specs.get('clear'))))
@permission_classes((permissions.Write,))
def post(self, collection):
"""Clear documents in collection."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
res = facade.clear_collection(collection, data)
return res, 200
except gmap_exc.CollectionNotExist as err:
app.logger.error(err.message)
api.abort(404, errors=err.message)
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
class CreateAuth(Resource):
@api.doc(responses={
200: 'Success',
401: 'Unauthorized',
})
@api.expect(api.schema_model('Auth', get_dict(specs.get('auth'))))
def post(self):
"""Create token"""
try:
data = request.get_json()
if type(data) is dict:
username = data.get('username')
password = data.get('password')
else:
username = None
password = None
if not username or not password:
app.logger.error('Username and Password is required.')
api.abort(401, errors='Username and Password is required.')
token = facade.create_token(username, password)
return token, 200
except exceptions.Unauthorized:
app.logger.error('User %s not authorized.', username)
api.abort(401, 'User not authorized.')
except exceptions.AuthException:
app.logger.error('Auth Unavailable.')
api.abort(503, 'Auth Unavailable.')
except AuthException:
app.logger.error('Auth Unavailable.')
api.abort(503, 'Auth Unavailable.')
class Graph(Resource):
@api.doc(responses={200: 'Success', 401: 'Unauthorized', 403: 'Forbidden'})
@permission_classes((permissions.Read, permissions.Graph))
def get(self):
"""List all graphs from DB."""
graphs = facade.list_graphs()
return graphs, 200
@api.doc(
responses={
200: 'Success',
401: 'Unauthorized',
403: 'Forbidden',
400: 'Validation Error',
})
@api.expect(api.schema_model('GraphPost', get_dict(SPECS.get('graphs'))))
@permission_classes(
(permissions.Write, permissions.Graph, permissions.Admin))
def post(self):
"""Create graph in DB."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
facade.create_graph(data)
return {}, 200
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
class Query(Resource):
@api.doc(responses={
200: 'Success',
401: 'Unauthorized',
403: 'Forbidden',
})
@api.expect(query_parsers.search_query_parser)
@permission_classes((permissions.Read, permissions.Collection))
def get(self):
"""List all queries from DB."""
args = query_parsers.search_query_parser.parse_args(request)
page = args.get('page')
per_page = args.get('per_page')
query = args.get('query')
data = json.loads(query)
queries = facade.list_query(data, page, per_page)
return queries, 200
@api.doc(responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
409: 'Document Already Exists'
})
@api.expect(api.schema_model('QueryPost',
get_dict(SPECS.get('queries'))))
@permission_classes((
permissions.Write, permissions.Collection, permissions.Admin))
def post(self):
"""Create queries in DB."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
res = facade.create_query(data)
return res, 200
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
except gmap_exc.QueryException as error:
app.logger.warning(error.message)
api.abort(400, errors=error.message)
except gmap_exc.DocumentAlreadyExist:
res = 'Cannot create query, already created.'
app.logger.warning(res)
api.abort(409, errors=res)
class Collections(Resource):
@api.doc(responses={
200: 'Success',
401: 'Unauthorized',
403: 'Forbidden',
})
@api.expect(search_parser)
@permission_classes((permissions.Read,))
def get(self):
"""List all collections of kind document from DB."""
args = search_parser.parse_args(request)
try:
query = args.get('query') or '[]'
page = args.get('page')
per_page = args.get('per_page')
data = json.loads(query)
res = facade.list_collections('document', data, page, per_page)
except JSONDecodeError:
raise gmap_exc.SearchException('Parameter query is invalid')
else:
return res, 200
@api.doc(responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@permission_classes((permissions.Admin,))
@api.expect(api.schema_model('Collections',
get_dict(specs.get('collections'))))
def post(self):
"""Create collection of kind document in DB."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
facade.create_collection_document(data)
return {}, 200
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
except gmap_exc.CollectionNotExist as err:
app.logger.error(err.message)
api.abort(404, errors=err.message)
class Graph(Resource):
@api.doc(responses={200: 'Success', 401: 'Unauthorized', 403: 'Forbidden'})
@api.expect(search_parser)
@permission_classes((permissions.Read, ))
def get(self):
"""List all graphs from DB."""
args = search_parser.parse_args(request)
try:
page = args.get('page')
per_page = args.get('per_page')
res = facade.list_graphs(page, per_page)
except JSONDecodeError:
raise gmap_exc.SearchException('Parameter query is invalid')
else:
return res, 200
@api.doc(
responses={
200: 'Success',
401: 'Unauthorized',
403: 'Forbidden',
400: 'Validation Error',
})
@api.expect(api.schema_model('GraphPost', get_dict(specs.get('graphs'))))
@permission_classes((permissions.Admin, ))
def post(self):
"""Create graph in DB."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
facade.create_graph(data)
return {}, 200
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
class Document(Resource):
@api.doc(responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@api.expect(api.schema_model('DocumentPut',
get_dict(specs.get('documents'))))
@permission_classes((permissions.Write,))
def put(self, collection, key):
"""Update document."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
res = facade.update_document(collection, key, data)
return res, 200
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
except gmap_exc.CollectionNotExist as err:
app.logger.error(err.message)
api.abort(404, errors=err.message)
except gmap_exc.DocumentNotExist as err:
app.logger.warning(err.message)
api.abort(404, errors=err.message)
@api.doc(responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@api.expect(api.schema_model('DocumentPatch',
get_dict(specs.get('documents_partial'))))
@permission_classes((permissions.Write,))
def patch(self, collection, key):
"""Partial update document."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
res = facade.patch_document(collection, key, data)
return res, 200
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
except gmap_exc.CollectionNotExist as err:
app.logger.error(err.message)
api.abort(404, errors=err.message)
except gmap_exc.DocumentNotExist as err:
app.logger.warning(err.message)
api.abort(404, errors=err.message)
@api.doc(responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@permission_classes((permissions.Read,))
def get(self, collection, key):
"""Get document by key."""
try:
res = facade.get_document(collection, key)
return res, 200
except gmap_exc.CollectionNotExist as err:
app.logger.error(err.message)
api.abort(404, errors=err.message)
except gmap_exc.DocumentNotExist as err:
app.logger.warning(err.message)
api.abort(404, errors=err.message)
@api.doc(responses={
200: 'Success',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@permission_classes((permissions.Write,))
def delete(self, collection, key):
"""Delete document by key."""
try:
facade.delete_document(collection, key)
return {}, 200
except gmap_exc.CollectionNotExist as err:
app.logger.error(err.message)
api.abort(404, errors=err.message)
except gmap_exc.DocumentNotExist as err:
app.logger.warning(err.message)
api.abort(404, errors=err.message)
class Collection(Resource):
@api.doc(responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found',
409: 'Document Already Exists'
})
@api.expect(api.schema_model('DocumentPost',
get_dict(specs.get('documents'))))
@permission_classes((permissions.Write,))
def post(self, collection):
"""Insert document in DB."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
res = facade.create_document(collection, data)
return res, 200
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
except gmap_exc.CollectionNotExist as err:
app.logger.error(err.message)
api.abort(404, errors=err.message)
except gmap_exc.DocumentAlreadyExist as err:
app.logger.warning(err.message)
api.abort(409, errors=err.message)
except gmap_exc.DocumentException as err:
app.logger.error(err.message)
api.abort(400, errors=err.message)
@api.doc(responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found',
409: 'Document Already Exists'
})
@api.expect(coll_parsers.search_parser)
@permission_classes((permissions.Read,))
def get(self, collection):
"""Search documents from collection."""
args = coll_parsers.search_parser.parse_args(request)
try:
try:
page = args.get('page')
query = args.get('query') or '[]'
per_page = args.get('per_page')
data = json.loads(query)
except JSONDecodeError:
raise gmap_exc.SearchException('Parameter query is invalid')
else:
res = facade.search(collection, data, page, per_page)
return res, 200
except gmap_exc.CollectionNotExist as err:
app.logger.error(err.message)
api.abort(404, errors=err.message)
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
class DocumentQuery(Resource):
@api.doc(
responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@api.expect(api.schema_model('QueryPut', get_dict(specs.get('queries'))))
@permission_classes((permissions.Write, ))
def put(self, key):
"""Update query in DB."""
try:
data = request.get_json()
app.logger.debug('Receive Data: %s', data)
res = facade.update_query(key, data)
return res, 200
except ValidationError as error:
res = validate(error)
app.logger.error(res)
api.abort(400, errors=res)
except gmap_exc.QueryException as error:
app.logger.warning(error.message)
api.abort(400, errors=error.message)
except gmap_exc.DocumentNotExist as error:
app.logger.warning(error.message)
api.abort(404, errors=error.message)
@api.doc(
responses={
200: 'Success',
400: 'Validation Error',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@permission_classes((permissions.Read, ))
def get(self, key):
"""Get query by key."""
try:
res = facade.get_query(key)
return res, 200
except gmap_exc.DocumentNotExist as error:
app.logger.warning(error.message)
api.abort(404, errors=error.message)
@api.doc(responses={
200: 'Success',
401: 'Unauthorized',
403: 'Forbidden',
404: 'Not Found'
})
@permission_classes((permissions.Write, ))
def delete(self, key):
"""Delete query by key."""
try:
res = facade.delete_query(key)
return res, 200
except gmap_exc.DocumentNotExist as error:
app.logger.warning(error.message)
api.abort(404, errors=error.message)
