def get(self):
log.info('Getting pending invitation for: {}'.format(current_identity.id))
try:
session.rollback()
response = get_pending_invitation(user_id=current_identity.id)
session.commit()
return response
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="GET-CHANNEL-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
finally:
session.close()
def post(self):
signup_request_format = reqparse.RequestParser()
signup_request_format.add_argument('username', type=non_empty_str, required=True, help="SIGNUP-REQ-USERNAME")
signup_request_format.add_argument('password', type=non_empty_str, required=True, help="SIGNUP-REQ-PASSWORD")
signup_request_format.add_argument('first_name', type=non_empty_str, required=True, help="SIGNUP-REQ-FIRSTNAME")
signup_request_format.add_argument('last_name', type=non_empty_str, required=False, help="SIGNUP-REQ-LASTNAME")
params = signup_request_format.parse_args()
log.info('SingUp kwargs: {}'.format(params))
try:
session.rollback()
response = signup(**params)
session.commit()
return response
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="SIGNUP-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
finally:
session.close()
def get(self, channel_name):
try:
log.info('Fetch Channel name: {}'.format(channel_name))
session.rollback()
response = get_channel_by_name(channel_name=channel_name)
session.commit()
return channel_response_transformation(response) if response else None
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="GET-CHANNEL-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
finally:
session.close()
def post(self):
join_channel_request_format = reqparse.RequestParser()
join_channel_request_format.add_argument('channel_name', type=non_empty_str, required=True,
help="CHANNEL-REQ-NAME")
join_channel_request_format.add_argument('invited_user_name', type=non_empty_str, required=True,
help="REQ-USER-NAME")
params = join_channel_request_format.parse_args()
params.update(dict(user_id=current_identity.id))
log.info('Channel Join Invitation request params: {}'.format(params))
try:
session.rollback()
response = join_channel_request(**params)
session.commit()
return response
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="GET-CHANNEL-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
finally:
session.close()
def post(self):
fetch_message_stream_request_format = reqparse.RequestParser()
fetch_message_stream_request_format.add_argument('channel', type=non_empty_str, required=True, help="MSG-STREAM-REQ-CHANNEL")
fetch_message_stream_request_format.add_argument('published_by', type=non_empty_str, required=True, help="MSG-STREAM-REQ-PUBLISHER")
fetch_message_stream_request_format.add_argument('message', type=non_empty_str, required=True, help="MSG-STREAM-REQ-MESSAGE")
params = fetch_message_stream_request_format.parse_args()
try:
session.rollback()
response = fetch_stream_messages(**params)
session.commit()
return response
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="MSG-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
finally:
session.close()
def get(self):
try:
response = get_user_by_id(user_id=current_identity.id)
session.commit()
return dict(
username=response.username,
first_name=response.first_name,
last_name=response.last_name,
created_on=response.created_on,
)
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="USR-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
finally:
session.close()
def process_messages():
try:
connection = pika.BlockingConnection(pika.ConnectionParameters(
host=PIKA_RABBITMQ_HOST))
pika_channel = connection.channel()
pika_channel.exchange_declare(exchange=PIKA_RABBITMQ_EXCHANGE,
type=PIKA_RABBITMQ_TYPE)
result = pika_channel.queue_declare(exclusive=True)
queue_name = result.method.queue
pika_channel.queue_bind(exchange=PIKA_RABBITMQ_EXCHANGE,
queue=queue_name)
def callback_function(ch, method, properties, body):
log.info('Pika Client Message payload: {}'.format(body))
payload = json.loads(body)
payload.update(dict(
id=str(uuid4()),
))
chat_obj = ChatHistory(**payload)
session.add(chat_obj)
session.commit()
pika_channel.basic_consume(callback_function,
queue=queue_name,
no_ack=True)
pika_channel.start_consuming()
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
except ConnectionClosed as pika_exception:
log.error(repr(pika_exception))
session.rollback()
abort(400, message='PIKA-CONNECTION-ERROR')
except AMQPConnectionError as pika_conn_err:
log.error(repr(pika_conn_err))
session.rollback()
abort(400, message='PIKA-CONNECTION-ERROR')
except Exception as excp:
log.error(repr(excp))
session.rollback()
finally:
session.close()
def get(self):
try:
session.rollback()
channel_list = get_user_channels(user_id=current_identity.id)
session.commit()
return [user_channel_response_transformation(channel) for channel in channel_list] if channel_list else None
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="PUB-INVALID-PARAM")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
finally:
session.close()
def tearDownClass(cls):
super(TestChannel, cls).tearDownClass()
session.rollback()
def post(self):
unsubscribe_channel_request_format = reqparse.RequestParser()
unsubscribe_channel_request_format.add_argument('channel_name', type=non_empty_str, required=True,
help="CHANNEL-REQ-NAME")
params = unsubscribe_channel_request_format.parse_args()
params.update(dict(user_id=current_identity.id))
log.info('Channel unsubscibe params: {}'.format(params))
try:
session.rollback()
response = unsubscribe_channel(**params)
session.commit()
return channel_unsubscribe_transform_response(response)
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="UNSUB-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
except Exception as excp:
log.error(repr(excp))
session.rollback()
abort(400, message=excp.message)
finally:
session.close()
def tearDownClass(cls):
super(TestUser, cls).tearDownClass()
session.rollback()
def post(self):
publish_message_request_format = reqparse.RequestParser()
publish_message_request_format.add_argument('message', type=non_empty_str, required=True, help="PUB-REQ-MESSAGE")
publish_message_request_format.add_argument('channel_name', type=non_empty_str, required=True, help="PUB-REQ-CHANNEL")
params = publish_message_request_format.parse_args()
params.update(dict(user_id=current_identity.id))
log.info('Publish params: {}'.format(params))
try:
session.rollback()
response = publish_message(**params)
session.commit()
return response
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="PUB-INVALID-PARAM")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
except ConnectionClosed as pika_exception:
log.error(repr(pika_exception))
session.rollback()
abort(400, message='PIKA-CONNECTION-ERROR')
except AMQPConnectionError as pika_conn_err:
log.error(repr(pika_conn_err))
session.rollback()
abort(400, message='PIKA-CONNECTION-ERROR')
except Exception as excp:
log.error(repr(excp))
session.rollback()
finally:
session.close()
def post(self):
delete_chat_params = reqparse.RequestParser()
delete_chat_params.add_argument('channel_name', type=non_empty_str, required=True,
help="MSG-DELETE-REQ-CHANNEL")
params = delete_chat_params.parse_args()
params.update(dict(user_id=current_identity.id))
try:
session.rollback()
response = delete_chat(**params)
session.commit()
return response
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="MSG-DELETE-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
except Exception as excp:
log.error(repr(excp))
session.rollback()
abort(400, message=excp.message)
finally:
session.close()
def post(self):
fetch_message_request_format = reqparse.RequestParser()
fetch_message_request_format.add_argument('channel_name', type=non_empty_str, required=True, help="MSG-FETCH-REQ-CHANNEL")
fetch_message_request_format.add_argument('page_num', type=int, required=True, help="MSG-FETCH-REQ-PAGE-NUM")
params = fetch_message_request_format.parse_args()
params.update(dict(user_id=current_identity.id))
params.update(dict(page_size=PER_PAGE_RESPONSE_LIMIT))
try:
message_list = []
session.rollback()
response = fetch_message(**params)
session.commit()
for a_message in response:
setattr(a_message, 'published_by_name', get_user_by_id(user_id=a_message.published_by).first_name)
message_list.append(message_transformation(a_message))
return message_list
except ValueError as val_err:
log.error(repr(val_err))
session.rollback()
abort(400, message=val_err.message)
except KeyError as key_err:
log.error(repr(key_err))
session.rollback()
abort(400, message="MSG-INVALID-PARAM")
except IOError as io_err:
log.exception(io_err)
session.rollback()
abort(500, message="API-ERR-IO")
except SQLAlchemyError as sa_err:
log.exception(sa_err)
session.rollback()
abort(500, message="API-ERR-DB")
except Exception as excp:
log.error(repr(excp))
session.rollback()
abort(400, message=excp.message)
finally:
session.close()
