class MessageHandler(tornado.web.RequestHandler):
"""
ClassName MessageHandler
It inherits RequestHandler class which routes incoming requests to handler
This class is responsible for handling request related to Message Fetching activity
"""
def set_default_headers(self):
"""
Method set_default_headers()
To set default CORS Headers
"""
self.set_header("Access-Control-Allow-Origin", "*")
self.set_header("Access-Control-Allow-Headers", "x-requested-with, access-token")
self.set_header('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
self.set_header("Content-Type", "application/json")
def initialize(self):
self.db_manager = DBManager('mongo')
@tornado.web.asynchronous ## For Non Blocking IO
def get(self, method):
"""
Method get()
To get user list OR by ID
"""
channel_name = self.get_argument("name", '')
channels = self.db_manager.retrieve(collection='channel', filter_by={'channel_name':channel_name})
if not len(channels):
data = {
'message' : 'Channel Not Found !',
}
result = transformer.response_transform(data, status_code=404, message_type='error', message='Not Found. Failed to respond', service_code='API_FAIL_010', hint='Channel name should be registered first')
self.set_status(404)
else:
messages = self.db_manager.retrieve(collection='channel_message__'+channels[0]['channel_name'], filter_by={})
result = transformer.response_transform([message for message in messages])
self.set_status(200)
self.write(json.dumps(result)) ## As it accepts only bytes, unicode, and dict objects
self.finish()
def options(self):
"""
Method options()
For Option Call
It doesnot contains any body
"""
self.set_status(204)
self.finish()
class ChannelDataHandler(object):
def __init__(self):
self.db_manager = DBManager('mongo')
self.channel_users = {}
def attach_client_to_channel(self, channel_id, client_id):
client_channel = self.db_manager.retrieve(collection='channel_client', filter_by={'channel_id':channel_id, 'client_id':client_id})
if not len(client_channel):
data = {
'_id' : str(utility.generate_uuid()),
'id' : str(utility.generate_uuid()),
'channel_id' : channel_id,
'client_id' : client_id,
'created_at' : str(utility.get_date_time()),
'updated_at' : str(utility.get_date_time()),
}
self.db_manager.create(collection='channel_client', data=data)
return channel_id, client_id
def set_client_channel_connection(self, client_id, channel_id, ws_connection):
if channel_id not in self.channel_users:
self.channel_users[channel_id] = {}
if client_id not in self.channel_users[channel_id]:
self.channel_users[channel_id][client_id] = ws_connection
self.send_pong_on_join(client_id, channel_id)
def send_pong_on_join(self, client_id, channel_id):
return self.send_message(client_id, channel_id, 'join', 'Joined the Channel')
def send_pong_on_leave(self, client_id, channel_id):
return self.send_message(client_id, channel_id, 'leave', 'Left the Channel')
def send_message(self, client_id, channel_id, message_type, payload):
user = self.db_manager.retrieve(collection='users', filter_by={'id':client_id})[0]
channel = self.db_manager.retrieve(collection='channel', filter_by={'id':channel_id})[0]
data = transformer.message_transform(user=user, channel=channel, message_type=message_type, payload=payload)
message = json.loads(data)
message['_id'] = str(utility.generate_uuid())
message['id'] = str(utility.generate_uuid())
message['created_at'] = str(utility.get_date_time())
message['updated_at'] = str(utility.get_date_time())
self.db_manager.create(collection='channel_message__'+channel['channel_name'], data=message)
for client in self.channel_users[channel_id]:
self.channel_users[channel_id][client].write_message(data)
def remove_client_channel_connection(self, client_id, channel_id):
if channel_id in self.channel_users and client_id in self.channel_users[channel_id]:
del self.channel_users[channel_id][client_id]
return self.send_pong_on_leave(client_id, channel_id)
def __init__(self):
self.db_manager = DBManager('mongo')
self.channel_users = {}
class ChannelHandler(tornado.web.RequestHandler):
"""
ClassName ChannelHandler
This class is used for creating/deleting channel and adding/removing client connection
"""
def set_default_headers(self):
self.set_header("Access-Control-Allow-Origin", "*")
self.set_header("Access-Control-Allow-Headers", "*")
self.set_header('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
self.set_header("Content-Type", "application/json")
def initialize(self):
self.db_manager = DBManager('mongo')
@tornado.web.asynchronous
def get(self, method):
"""
Method get()
To get channel list OR by ID
"""
channel_name = self.get_argument("channel", None)
if channel_name is None:
channels = self.db_manager.list(collection='channel')[::-1]
else:
channels = self.db_manager.retrieve(collection='channel', filter_by={'channel_name':channel_name})
result = transformer.response_transform([transformer.channel_transform(channel) for channel in channels])
self.write(json.dumps(result)) ## As it accepts only bytes, unicode, and dict objects
self.set_status(200)
self.finish()
@tornado.web.asynchronous
def post(self, method):
"""
Method post()
To register a channel
"""
data = json.loads(self.request.body)
channel_name = data['name'] if 'name' in data else ''
if channel_name == '' or len(channel_name) < 5:
data = {
'message' : 'Please Provide Valid Channel Name !',
}
result = transformer.response_transform(data, status_code=400, message_type='error', message='Bad Request. Failed to respond', service_code='API_FAIL_001', hint='Channel name should be more than 4 words')
self.set_status(400)
else:
channels = self.db_manager.retrieve(collection='channel', filter_by={'channel_name':slugify(channel_name, max_length=30, word_boundary=True, save_order=True)})
if len(channels):
data = {
'message' : 'Channel Name Already Exists !',
}
result = transformer.response_transform(data, status_code=409, message_type='error', message='Duplicate Entry. Failed to respond', service_code='API_FAIL_002', hint='Try with different channel name')
self.set_status(409)
else:
data = {
'_id' : str(utility.generate_uuid()),
'id' : str(utility.generate_uuid()),
'channel_name' : slugify(channel_name, max_length=30, word_boundary=True, save_order=True),
'created_at' : str(utility.get_date_time()),
'updated_at' : str(utility.get_date_time()),
}
channel = self.db_manager.create(collection='channel', data=data)
if channel:
del data['_id']
result = transformer.response_transform(data, status_code=201, service_code='API_SUCCESS_001', hint='Channel Added Successfully')
self.set_status(201)
else:
data = {
'message' : 'Failed To Register Channel. Try Again !',
}
result = transformer.response_transform(data, status_code=500, message_type='error', message='Something Went Wrong', service_code='API_FAIL_003', hint='We messed up !')
self.set_status(500)
self.write(json.dumps(result))
self.finish()
def options(self, method=None):
"""
Method options()
For Option Call
It doesnot contains any body
"""
self.set_status(204)
self.finish()
def initialize(self):
self.db_manager = DBManager('mongo')
class UserHandler(tornado.web.RequestHandler):
"""
ClassName UserHandler
It inherits RequestHandler class which routes incoming requests to handler
This class is responsible for handling request related to User CRUD activity
"""
def set_default_headers(self):
"""
Method set_default_headers()
To set default CORS Headers
"""
self.set_header("Access-Control-Allow-Origin", "*")
self.set_header("Access-Control-Allow-Headers", "*")
self.set_header('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
self.set_header("Content-Type", "application/json")
def initialize(self):
self.db_manager = DBManager('mongo')
@tornado.web.asynchronous ## For Non Blocking IO
def get(self, method):
"""
Method get()
To get user list OR by ID
"""
username = self.get_argument("username", None)
if username is None:
users = self.db_manager.list(collection='users')[::-1]
else:
users = self.db_manager.retrieve(collection='users',
filter_by={'username': username})
result = transformer.response_transform(
[transformer.user_transform(user) for user in users])
self.set_status(200)
self.write(json.dumps(
result)) ## As it accepts only bytes, unicode, and dict objects
self.finish()
@tornado.web.asynchronous ## For Non Blocking IO
def post(self, method):
"""
Method post()
To add a user to db record
"""
data = json.loads(self.request.body)
username = data['username'] if 'username' in data else ''
display_name = data['display_name'] if 'display_name' in data else ''
if username == '' or display_name == '':
data = {
'message': 'Please Provide Valid Username and Display Name !',
}
result = transformer.response_transform(
data,
status_code=400,
message_type='error',
message='Bad Request. Failed to respond',
service_code='API_FAIL_004',
hint='Username and Display Name is Required')
self.set_status(400)
else:
users = self.db_manager.retrieve(collection='users',
filter_by={
'username':
slugify(username,
max_length=30,
word_boundary=True,
save_order=True)
})
if len(users):
data = {
'message': 'Username Already Taken !',
}
result = transformer.response_transform(
data,
status_code=409,
message_type='error',
message='Duplicate Entry. Failed to respond',
service_code='API_FAIL_002',
hint='Try with different username')
self.set_status(409)
else:
data = {
'_id':
str(utility.generate_uuid()),
'id':
str(utility.generate_uuid()),
'username':
slugify(username,
max_length=30,
word_boundary=True,
save_order=True),
'display_name':
display_name,
'created_at':
str(utility.get_date_time()),
'updated_at':
str(utility.get_date_time()),
}
user = self.db_manager.create(collection='users', data=data)
if user:
del data['_id']
result = transformer.response_transform(
data,
status_code=201,
service_code='API_SUCCESS_003',
hint='User Added Successfully')
self.set_status(201)
else:
data = {
'message': 'Failed To Register User. Try Again !',
}
result = transformer.response_transform(
data,
status_code=500,
message_type='error',
message='Something Went Wrong',
service_code='API_FAIL_006',
hint='We messed up !')
self.set_status(500)
self.write(json.dumps(result))
self.finish()
def options(self, method=None):
"""
Method options()
For Option Call
It doesnot contains any body
"""
self.set_status(204)
self.finish()
class MainHandler(tornado.web.RequestHandler):
"""
ClassName MainHandler
It inherits RequestHandler class which routes incoming requests to handlers
In this hadler, methods gets called on the basis of request type
"""
def set_default_headers(self):
"""
Method set_default_headers()
To set default CORS Headers
"""
self.set_header("Access-Control-Allow-Origin", "*")
self.set_header("Access-Control-Allow-Headers", "x-requested-with, access-token")
self.set_header('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
self.set_header("Content-Type", "text/html; charset=UTF-8")
def initialize(self):
self.db_manager = DBManager('mongo')
self.channel_data_handler = ChannelDataHandler()
@tornado.web.asynchronous ## For Non Blocking IO
def get(self):
"""
Method get()
@param self
Gets called on GET request method call
"""
channel_name = self.get_argument("channel", None)
username = self.get_argument("username", None)
if not channel_name or not username: ## If Channel Or User Not Provided, Render To Home Page
self.render("../templates/index.html")
else:
channel = self.db_manager.retrieve(collection='channel', filter_by={'channel_name':channel_name})
user = self.db_manager.retrieve(collection='users', filter_by={'username':username})
if not len(channel) or not len(user):
data = {
'message' : 'Channel Or User Not Found !',
}
result = transformer.response_transform(data, status_code=404, message_type='error', message='Not Found. Failed to respond', service_code='API_FAIL_009', hint='Channel Or Username is Not Registered. Please Register First')
self.set_status(404) ## For Setting Up HTTP Status Code
self.write(json.dumps(result)) ## As it accepts only bytes, unicode, and dict objects
self.finish()
else:
channel_id, client_id = self.channel_data_handler.attach_client_to_channel(channel[0]['id'], user[0]['id'])
data = {
'channel_id' : channel_id,
'client_id' : client_id
}
result = transformer.response_transform(data, status_code=200, message_type='success', message='Successfully Responded', service_code='API_SUCCESS_014', hint='Channel and Client Found')
self.set_header("Content-Type", "application/json")
self.set_status(200) ## For Setting Up HTTP Status Code
self.write(json.dumps(result)) ## As it accepts only bytes, unicode, and dict objects
self.finish()
# self.render("../templates/chat.html", client_id=client_id, channel_id=channel_id)
@tornado.web.asynchronous ## For Non Blocking IO
def post(self):
self.set_header("Content-Type", "text/plain")
self.write("You wrote " + self.get_body_argument("message"))
self.finish()
def initialize(self):
self.db_manager = DBManager('mongo')
self.channel_data_handler = ChannelDataHandler()