def get(self):
"""
:return:
"""
try:
log.info('%s %r' % (request.remote_addr, request))
response = []
if len(request.args) > 0:
persons = ModelOperations.person_filter(request)
else:
persons = ModelOperations.person_list()
if not persons:
return jsonify(persons=response)
response = [{
"mentions": int(person[0]),
"name": person[1]
} for person in persons]
return jsonify(persons=response)
except Exception as exception:
log.exception(exception)
return Response(json.dumps(errors.API_ERROR),
status=500,
mimetype=settings.API_MIME_TYPE)
def get(self):
"""
:return:
"""
try:
log.info('%s %r' % (request.remote_addr, request))
if len(request.args) > 0:
news_list = ModelOperations.news_filter(request)
else:
news_list = Model.News.query.order_by(
Model.News.published_at.desc()).limit(
settings.MAX_NEWS).all()
if news_list:
log.info('api() | %d News found ' % len(news_list))
# Extract fields: ['title', 'content', 'url', 'published_at',
# 'provider']
response = [{
field: getattr(news, field)
for field in settings.NEWS_FIELDS
} for news in news_list]
return jsonify(news=response, status='ok', source='news_ml')
log.warn('api() | No News articles found')
return Response(json.dumps(errors.NO_NEWS),
status=404,
mimetype=settings.API_MIME_TYPE)
except UnboundLocalError as exception:
log.exception(exception)
response = json.dumps(errors.INVALID_REQUEST)
return Response(response,
status=400,
mimetype=settings.API_MIME_TYPE)
def post(self):
"""
:return:
"""
try:
log.info('%s %r' % (request.remote_addr, request))
log.info('api() | POST | Received request for Person')
# Assign API request information
person_instance = api_controller.get_person(request.json)
# Returns valid CampaignD object
if not person_instance:
log.error('api() | Unable to process Person request %r',
request.data)
response = json.dumps(errors.INVALID_PERSON)
resp = Response(response,
status=422,
mimetype=settings.API_MIME_TYPE)
return resp
person_instance.id = ModelOperations.insert_person(
person_instance.name, settings.DBNOW)
response = jsonify({'person_id': person_instance.id})
response.headers['Location'] = api.url_for(
api(current_app),
Person,
ref=person_instance.id,
_external=True,
_scheme=settings.API_SCHEME)
response.status_code = 202
return response
except Exception as exception:
log.exception(exception)
return Response(json.dumps(errors.API_ERROR),
status=500,
mimetype=settings.API_MIME_TYPE)
def post(self):
"""
:return:
"""
try:
log.info('%s %r' % (request.remote_addr, request))
log.info('api() | POST | Received request for Clustering')
# Assign API request information.
clustering_instance = api_controller.get_clustering(
request.json) or None
# Returns valid ClusterD object.
if not clustering_instance:
log.error('api() | Unable to process Clustering request %r',
request.data)
response = json.dumps(errors.INVALID_CAMPAIGN)
resp = Response(response,
status=422,
mimetype=settings.API_MIME_TYPE)
return resp
celery.send_task(
'process_clustering',
exchange='news_ml',
queue='gold',
routing_key='news_ml.gold',
kwargs={'clustering_instance': clustering_instance},
retries=3)
response = jsonify(
{'campaign_id': clustering_instance.campaign_reference})
response.headers['Location'] = api.url_for(
api(current_app),
Campaign,
ref=clustering_instance.campaign_reference,
_external=True,
_scheme=settings.API_SCHEME)
response.status_code = 202
return response
except UnboundLocalError as exception:
log.exception(exception)
response = json.dumps(errors.INVALID_REQUEST)
resp = Response(response,
status=500,
mimetype=settings.API_MIME_TYPE)
return resp
finally:
# Insert campaign details into database.
if clustering_instance:
clustering_instance.id = ModelOperations.insert_campaign(
0, 'Cluster %s' % clustering_instance.campaign_reference,
clustering_instance.campaign_reference, settings.DBNOW,
request.data.decode('utf-8'), clustering_instance.provider,
clustering_instance.send_report,
clustering_instance.num_of_articles, False)
def post(self):
"""Inserts a Ranked article.
:return:
"""
try:
log.info('%s %r' % (request.remote_addr, request))
log.info('api() | POST | Received request for Ranking')
ranker_instance = api_controller.get_ranker(request.json) or None
# Returns a RankerD object used to rank existing articles in DB.
if not ranker_instance:
log.error('api() | Unable to process Ranker request %r',
request.data)
response = json.dumps(errors.INVALID_RANKER)
resp = Response(response,
status=422,
mimetype=settings.API_MIME_TYPE)
return resp
celery.send_task('rank_news',
exchange='news_ml',
queue='gold',
routing_key='news_ml.gold',
kwargs={'ranker_instance': ranker_instance},
retries=3)
response = jsonify(
{'campaign_id': ranker_instance.campaign_reference})
response.headers['Location'] = api.url_for(
api(current_app),
Campaign,
ref=ranker_instance.campaign_reference,
_external=True,
_scheme=settings.API_SCHEME)
response.status_code = 202
return response
except UnboundLocalError as e:
log.exception(e)
response = json.dumps(errors.INVALID_REQUEST)
resp = Response(response,
status=500,
mimetype=settings.API_MIME_TYPE)
return resp
finally:
# Insert Ranker campaign details into database.
if ranker_instance:
ranker_instance.id = ModelOperations.insert_campaign(
0, 'Ranker '
'%s' % ranker_instance.campaign_reference,
ranker_instance.campaign_reference, settings.DBNOW,
request.data.decode('utf-8'), 'RANKER',
ranker_instance.send_report,
ranker_instance.num_of_articles, False)
def get(self):
"""Get List of users.
:return:
"""
try:
log.info('%s %r' % (request.remote_addr, request))
users = ModelOperations.user_list()
if not users:
response = jsonify(users=[])
response.status_code = 404
return response
response = [{
"id": user[0],
"username": user[1],
"created": user[2]
} for user in users]
return jsonify(users=response)
except KeyError as key_error:
log.exception(key_error)
def post(self):
"""Creates a new user.
New user requires a valid username and password. Password is clear text.
API uses HTTPS hence password should be unreadable if intercepted.
:return:
"""
try:
log.info('%s %r' % (request.remote_addr, request))
# Get authentication parameters.
username = request.json.get('username')
password = request.json.get('password')
if username is None or password is None:
log.error('api() | Provide username and password.')
response = json.dumps('Provide username and password')
return Response(response,
status=400,
mimetype=settings.API_MIME_TYPE)
if Model.ApiUsers.query.filter_by(
username=username).first() is not None:
log.error('api() | Username already exists.')
response = json.dumps('Username already exists')
return Response(response,
status=400,
mimetype=settings.API_MIME_TYPE)
user_id = ModelOperations.insert_user(username, password, 'now()')
response = jsonify({'id': user_id})
response.headers['Location'] = api.url_for(
api(current_app),
ApiUser,
id=user_id,
_external=True,
_scheme=settings.API_SCHEME)
response.status_code = 201
return response
except Exception as exception:
log.exception(exception)
response = json.dumps(errors.API_ERROR)
return Response(response,
status=500,
mimetype=settings.API_MIME_TYPE)