def publish_message(**kwargs):
log.info('Publish Message kwargs: {}'.format(kwargs))
user = get_user_by_id(user_id=kwargs['user_id'])
payload = dict(
published_by=user.id,
message=kwargs['message'],
channel=get_channel_by_name(channel_name=kwargs['channel_name']).id,
created_on=str(datetime.now()),
)
# Comment the following part upto conneciton.close(), to make the process sync
# And uncomment the below commented part, so that db call is done here and not in pika worker.
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)
pika_channel.basic_publish(exchange=PIKA_RABBITMQ_EXCHANGE,
routing_key='',
body=json.dumps(payload))
connection.close()
# payload.update(dict(
# id=str(uuid4()),
# ))
# chat_obj = ChatHistory(**payload)
# session.add(chat_obj)
# session.flush()
return dict(
message_published=True
)
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 delete_chat(**kwargs):
log.info('Delete chat kwargs: {}'.format(kwargs))
channel = get_channel_by_name(channel_name=kwargs['channel_name'])
chat_obj = session.query(UserChannelMapping) \
.filter(UserChannelMapping.user_id == kwargs['user_id'], UserChannelMapping.channel_id == channel.id)\
.first()
setattr(chat_obj, 'marked_deleted_on', datetime.now())
session.add(chat_obj)
return dict(
chat_deleted=True,
)
def fetch_message(**kwargs):
log.info('Fetch Message kwargs: {}'.format(kwargs))
message_list = []
user_id = kwargs['user_id']
channel_obj = get_channel_by_name(channel_name=kwargs['channel_name'])
if channel_obj and not is_channel_unsubscribed(channel_id=channel_obj.id, user_id=user_id):
page_size = kwargs['page_size']
page = kwargs['page_num']
message_list = session.query(ChatHistory) \
.filter(ChatHistory.channel == channel_obj.id, ChatHistory.deleted_on.is_(None)) \
.order_by(desc(ChatHistory.created_on))
if page_size:
message_list = message_list.limit(PER_PAGE_RESPONSE_LIMIT)
if page:
message_list = message_list.offset(page*page_size)
message_marked_deleted = chat_marked_deleted(user_id=user_id, channel_id=channel_obj.id)
if not message_marked_deleted[0]:
return message_list.all()
else:
return [message for message in message_list.all()
if message.created_on > message_marked_deleted[0]]
return message_list
def test_get_channel_by_name_for_key_error(self):
with self.assertRaises(KeyError) as err_empty_param:
channel.get_channel_by_name(channel_name_wrong=self.channel_id)
self.assertEqual('REQ-CHANNEL-NAME', err_empty_param.exception.message)
def test_get_channel_by_name_for_value_error(self):
with self.assertRaises(ValueError) as err_empty_string_param:
channel.get_channel_by_name(channel_name='')
self.assertEqual('REQ-CHANNEL-NAME', err_empty_string_param.exception.message)
