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()