WebRtcMessageCreator.__init__() - Code Metrics - Inspection of "Refactored tornado.py to a separate module" - Deathangel908/pychat - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7365f5...41cb1b )

by Andrew

created 2017-07-02 18:48 UTC

WebRtcMessageCreator.init() A

↳ Parent: WebRtcMessageCreator

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
dl	0
loc	3
rs	10

from chat.models import get_milliseconds
from chat.tornado.constants import VarNames, HandlerNames, Actions, RedisPrefix
from chat.tornado.image_utils import prepare_img


class MessagesCreator(object):

	def __init__(self, *args, **kwargs):
		self.sex = None
		self.sender_name = None
		self.user_id = 0  # anonymous by default

	def default(self, content, event, handler):
		"""
		:return: {"action": event, "content": content, "time": "20:48:57"}
		"""
		return {
			VarNames.EVENT: event,
			VarNames.CONTENT: content,
			VarNames.USER_ID: self.user_id,
			VarNames.TIME: get_milliseconds(),
			VarNames.HANDLER_NAME: handler
		}

	@staticmethod
	def set_ws_id(random, self_id):
		return {
			VarNames.HANDLER_NAME: HandlerNames.WS,
			VarNames.EVENT: Actions.SET_WS_ID,
			VarNames.CONTENT: random,
			VarNames.WEBRTC_OPPONENT_ID: self_id
		}

	def room_online(self, online, event, channel):
		"""
		:return: {"action": event, "content": content, "time": "20:48:57"}
		"""
		room_less = self.default(online, event, HandlerNames.CHAT)
		room_less[VarNames.CHANNEL_NAME] = channel
		room_less[VarNames.USER] = self.sender_name
		room_less[VarNames.GENDER] = self.sex
		return room_less

	@classmethod
	def create_message(cls, message, images):
		res = {
			VarNames.USER_ID: message.sender_id,
			VarNames.CONTENT: message.content,
			VarNames.TIME: message.time,
			VarNames.MESSAGE_ID: message.id,
			VarNames.IMG: images
		}
		return res

	@classmethod
	def create_send_message(cls, message, event, imgs):
		"""
		:type message: chat.models.Message
		:type imgs: dict
		:type event: Actions
		:return: "action": "joined", "content": {"v5bQwtWp": "alien", "tRD6emzs": "Alien"},
		"sex": "Alien", "user": "tRD6emzs", "time": "20:48:57"}
		"""
		res = cls.create_message(message, imgs)
		res[VarNames.EVENT] = event
		res[VarNames.CHANNEL] = message.room_id
		res[VarNames.SYMBOL] = message.symbol
		res[VarNames.HANDLER_NAME] = HandlerNames.CHAT
		return res

	@classmethod
	def append_images(cls, messages, images):
		"""
		:type messages: list[chat.models.Message] 
		:type images: list[chat.models.Image] 
		"""
		res_mess = []
		for message in messages:
			res_images = prepare_img(images, message.id)
			res_mess.append(cls.create_message(message, res_images))
		return res_mess

	@classmethod
	def get_messages(cls, messages, channel, images):
		"""
		:type images: list[chat.models.Image]
		:type messages: list[chat.models.Message]
		:type channel: str
		"""
		return {
			VarNames.CONTENT: cls.append_images(messages, images),
			VarNames.EVENT: Actions.GET_MESSAGES,
			VarNames.CHANNEL: channel,
			VarNames.HANDLER_NAME: HandlerNames.CHAT
		}

	@property
	def channel(self):
		return RedisPrefix.generate_user(self.user_id)

	def subscribe_direct_channel_message(self, room_id, other_user_id):
		return {
			VarNames.EVENT: Actions.CREATE_DIRECT_CHANNEL,
			VarNames.ROOM_ID: room_id,
			VarNames.ROOM_USERS: [self.user_id, other_user_id],
			VarNames.HANDLER_NAME: HandlerNames.CHANNELS
		}

	def subscribe_room_channel_message(self, room_id, room_name):
		return {
			VarNames.EVENT: Actions.CREATE_ROOM_CHANNEL,
			VarNames.ROOM_ID: room_id,
			VarNames.ROOM_USERS: [self.user_id],
			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
			VarNames.ROOM_NAME: room_name
		}

	@staticmethod
	def invite_room_channel_message(room_id, user_id, room_name, users):
		return {
			VarNames.EVENT: Actions.INVITE_USER,
			VarNames.ROOM_ID: room_id,
			VarNames.USER_ID: user_id,
			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
			VarNames.ROOM_NAME: room_name,
			VarNames.CONTENT: users
		}

	@staticmethod
	def add_user_to_room(channel, user_id, content):
		return {
			VarNames.EVENT: Actions.ADD_USER,
			VarNames.CHANNEL: channel,
			VarNames.USER_ID: user_id,
			VarNames.HANDLER_NAME: HandlerNames.CHAT,
			VarNames.GENDER: content[VarNames.GENDER],  # SEX: 'Alien', USER: 'Andrew'
			VarNames.USER: content[VarNames.USER]  # SEX: 'Alien', USER: 'Andrew'
		}

	def unsubscribe_direct_message(self, room_id):
		return {
			VarNames.EVENT: Actions.DELETE_ROOM,
			VarNames.ROOM_ID: room_id,
			VarNames.USER_ID: self.user_id,
			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
			VarNames.TIME: get_milliseconds()
		}

	def load_offline_message(self, offline_messages, channel_key):
		res = self.default(offline_messages, Actions.OFFLINE_MESSAGES, HandlerNames.CHAT)
		res[VarNames.CHANNEL] = channel_key
		return res


class WebRtcMessageCreator(MessagesCreator):
	def __init__(self, *args, **kwargs):
		super(WebRtcMessageCreator, self).__init__(*args, **kwargs)
		self.id = None  # child init

	def offer_webrtc(self, content, connection_id, room_id, action):
		"""
		:return: {"action": "call", "content": content, "time": "20:48:57"}
		"""
		message = self.default(content, action, HandlerNames.WEBRTC)
		message[VarNames.USER] = self.sender_name
		message[VarNames.CONNECTION_ID] = connection_id
		message[VarNames.WEBRTC_OPPONENT_ID] = self.id
		message[VarNames.CHANNEL] = room_id
		return message

	def set_webrtc_error(self, error, connection_id, qued_id=None):
		message = self.default(error, Actions.SET_WEBRTC_ERROR, HandlerNames.PEER_CONNECTION)
		message[VarNames.CONNECTION_ID] = connection_id
		if qued_id:
			message[VarNames.WEBRTC_QUED_ID] = qued_id
		return message

	@staticmethod
	def set_connection_id(qued_id, connection_id):
		return {
			VarNames.EVENT: Actions.SET_WEBRTC_ID,
			VarNames.HANDLER_NAME: HandlerNames.WEBRTC,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.WEBRTC_QUED_ID: qued_id
		}

	def get_close_call_connection_message(self, connection_id):
		return {
			VarNames.EVENT: Actions.CLOSE_CALL_CONNECTION,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.USER_ID: self.user_id,
			VarNames.WEBRTC_OPPONENT_ID: self.id,
			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
		}

	def get_close_file_sender_message(self, connection_id):
		return {
			VarNames.EVENT: Actions.CLOSE_FILE_CONNECTION,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.WEBRTC_OPPONENT_ID: self.id,
			VarNames.HANDLER_NAME: HandlerNames.WEBRTC_TRANSFER,
		}

	def get_accept_file_message(self, connection_id):
		return {
			VarNames.EVENT: Actions.ACCEPT_FILE,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.WEBRTC_OPPONENT_ID: self.id,
			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
		}

	def get_accept_call_message(self, connection_id):
		return {
			VarNames.EVENT: Actions.ACCEPT_CALL,
			VarNames.USER_ID: self.user_id,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.WEBRTC_OPPONENT_ID: self.id,
			VarNames.HANDLER_NAME: HandlerNames.WEBRTC_TRANSFER,
		}

	def reply_webrtc(self, event, connection_id):
		"""
		:return: {"action": event, "content": content, "time": "20:48:57"}
		"""
		return {
			VarNames.EVENT: event,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.USER_ID: self.user_id,
			VarNames.USER: self.sender_name,
			VarNames.WEBRTC_OPPONENT_ID: self.id,
			VarNames.HANDLER_NAME: HandlerNames.WEBRTC_TRANSFER,
		}

1			from chat.models import get_milliseconds
2			from chat.tornado.constants import VarNames, HandlerNames, Actions, RedisPrefix
3			from chat.tornado.image_utils import prepare_img
4
5
6			class MessagesCreator(object):
7
8			def __init__(self, args, *kwargs):
9			self.sex = None
10			self.sender_name = None
11			self.user_id = 0 # anonymous by default
12
13			def default(self, content, event, handler):
14			"""
15			:return: {"action": event, "content": content, "time": "20:48:57"}
16			"""
17			return {
18			VarNames.EVENT: event,
19			VarNames.CONTENT: content,
20			VarNames.USER_ID: self.user_id,
21			VarNames.TIME: get_milliseconds(),
22			VarNames.HANDLER_NAME: handler
23			}
24
25			@staticmethod
26			def set_ws_id(random, self_id):
27			return {
28			VarNames.HANDLER_NAME: HandlerNames.WS,
29			VarNames.EVENT: Actions.SET_WS_ID,
30			VarNames.CONTENT: random,
31			VarNames.WEBRTC_OPPONENT_ID: self_id
32			}
33
34			def room_online(self, online, event, channel):
35			"""
36			:return: {"action": event, "content": content, "time": "20:48:57"}
37			"""
38			room_less = self.default(online, event, HandlerNames.CHAT)
39			room_less[VarNames.CHANNEL_NAME] = channel
40			room_less[VarNames.USER] = self.sender_name
41			room_less[VarNames.GENDER] = self.sex
42			return room_less
43
44			@classmethod
45			def create_message(cls, message, images):
46			res = {
47			VarNames.USER_ID: message.sender_id,
48			VarNames.CONTENT: message.content,
49			VarNames.TIME: message.time,
50			VarNames.MESSAGE_ID: message.id,
51			VarNames.IMG: images
52			}
53			return res
54
55			@classmethod
56			def create_send_message(cls, message, event, imgs):
57			"""
58			:type message: chat.models.Message
59			:type imgs: dict
60			:type event: Actions
61			:return: "action": "joined", "content": {"v5bQwtWp": "alien", "tRD6emzs": "Alien"},
62			"sex": "Alien", "user": "tRD6emzs", "time": "20:48:57"}
63			"""
64			res = cls.create_message(message, imgs)
65			res[VarNames.EVENT] = event
66			res[VarNames.CHANNEL] = message.room_id
67			res[VarNames.SYMBOL] = message.symbol
68			res[VarNames.HANDLER_NAME] = HandlerNames.CHAT
69			return res
70
71			@classmethod
72			def append_images(cls, messages, images):
73			"""
74			:type messages: list[chat.models.Message]
75			:type images: list[chat.models.Image]
76			"""
77			res_mess = []
78			for message in messages:
79			res_images = prepare_img(images, message.id)
80			res_mess.append(cls.create_message(message, res_images))
81			return res_mess
82
83			@classmethod
84			def get_messages(cls, messages, channel, images):
85			"""
86			:type images: list[chat.models.Image]
87			:type messages: list[chat.models.Message]
88			:type channel: str
89			"""
90			return {
91			VarNames.CONTENT: cls.append_images(messages, images),
92			VarNames.EVENT: Actions.GET_MESSAGES,
93			VarNames.CHANNEL: channel,
94			VarNames.HANDLER_NAME: HandlerNames.CHAT
95			}
96
97			@property
98			def channel(self):
99			return RedisPrefix.generate_user(self.user_id)
100
101			def subscribe_direct_channel_message(self, room_id, other_user_id):
102			return {
103			VarNames.EVENT: Actions.CREATE_DIRECT_CHANNEL,
104			VarNames.ROOM_ID: room_id,
105			VarNames.ROOM_USERS: [self.user_id, other_user_id],
106			VarNames.HANDLER_NAME: HandlerNames.CHANNELS
107			}
108
109			def subscribe_room_channel_message(self, room_id, room_name):
110			return {
111			VarNames.EVENT: Actions.CREATE_ROOM_CHANNEL,
112			VarNames.ROOM_ID: room_id,
113			VarNames.ROOM_USERS: [self.user_id],
114			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
115			VarNames.ROOM_NAME: room_name
116			}
117
118			@staticmethod
119			def invite_room_channel_message(room_id, user_id, room_name, users):
120			return {
121			VarNames.EVENT: Actions.INVITE_USER,
122			VarNames.ROOM_ID: room_id,
123			VarNames.USER_ID: user_id,
124			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
125			VarNames.ROOM_NAME: room_name,
126			VarNames.CONTENT: users
127			}
128
129			@staticmethod
130			def add_user_to_room(channel, user_id, content):
131			return {
132			VarNames.EVENT: Actions.ADD_USER,
133			VarNames.CHANNEL: channel,
134			VarNames.USER_ID: user_id,
135			VarNames.HANDLER_NAME: HandlerNames.CHAT,
136			VarNames.GENDER: content[VarNames.GENDER], # SEX: 'Alien', USER: 'Andrew'
137			VarNames.USER: content[VarNames.USER] # SEX: 'Alien', USER: 'Andrew'
138			}
139
140			def unsubscribe_direct_message(self, room_id):
141			return {
142			VarNames.EVENT: Actions.DELETE_ROOM,
143			VarNames.ROOM_ID: room_id,
144			VarNames.USER_ID: self.user_id,
145			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
146			VarNames.TIME: get_milliseconds()
147			}
148
149			def load_offline_message(self, offline_messages, channel_key):
150			res = self.default(offline_messages, Actions.OFFLINE_MESSAGES, HandlerNames.CHAT)
151			res[VarNames.CHANNEL] = channel_key
152			return res
153
154
155			class WebRtcMessageCreator(MessagesCreator):
156			def __init__(self, args, *kwargs):
157			super(WebRtcMessageCreator, self).__init__(args, *kwargs)
158			self.id = None # child init
159
160			def offer_webrtc(self, content, connection_id, room_id, action):
161			"""
162			:return: {"action": "call", "content": content, "time": "20:48:57"}
163			"""
164			message = self.default(content, action, HandlerNames.WEBRTC)
165			message[VarNames.USER] = self.sender_name
166			message[VarNames.CONNECTION_ID] = connection_id
167			message[VarNames.WEBRTC_OPPONENT_ID] = self.id
168			message[VarNames.CHANNEL] = room_id
169			return message
170
171			def set_webrtc_error(self, error, connection_id, qued_id=None):
172			message = self.default(error, Actions.SET_WEBRTC_ERROR, HandlerNames.PEER_CONNECTION)
173			message[VarNames.CONNECTION_ID] = connection_id
174			if qued_id:
175			message[VarNames.WEBRTC_QUED_ID] = qued_id
176			return message
177
178			@staticmethod
179			def set_connection_id(qued_id, connection_id):
180			return {
181			VarNames.EVENT: Actions.SET_WEBRTC_ID,
182			VarNames.HANDLER_NAME: HandlerNames.WEBRTC,
183			VarNames.CONNECTION_ID: connection_id,
184			VarNames.WEBRTC_QUED_ID: qued_id
185			}
186
187			def get_close_call_connection_message(self, connection_id):
188			return {
189			VarNames.EVENT: Actions.CLOSE_CALL_CONNECTION,
190			VarNames.CONNECTION_ID: connection_id,
191			VarNames.USER_ID: self.user_id,
192			VarNames.WEBRTC_OPPONENT_ID: self.id,
193			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
194			}
195
196			def get_close_file_sender_message(self, connection_id):
197			return {
198			VarNames.EVENT: Actions.CLOSE_FILE_CONNECTION,
199			VarNames.CONNECTION_ID: connection_id,
200			VarNames.WEBRTC_OPPONENT_ID: self.id,
201			VarNames.HANDLER_NAME: HandlerNames.WEBRTC_TRANSFER,
202			}
203
204			def get_accept_file_message(self, connection_id):
205			return {
206			VarNames.EVENT: Actions.ACCEPT_FILE,
207			VarNames.CONNECTION_ID: connection_id,
208			VarNames.WEBRTC_OPPONENT_ID: self.id,
209			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
210			}
211
212			def get_accept_call_message(self, connection_id):
213			return {
214			VarNames.EVENT: Actions.ACCEPT_CALL,
215			VarNames.USER_ID: self.user_id,
216			VarNames.CONNECTION_ID: connection_id,
217			VarNames.WEBRTC_OPPONENT_ID: self.id,
218			VarNames.HANDLER_NAME: HandlerNames.WEBRTC_TRANSFER,
219			}
220
221			def reply_webrtc(self, event, connection_id):
222			"""
223			:return: {"action": event, "content": content, "time": "20:48:57"}
224			"""
225			return {
226			VarNames.EVENT: event,
227			VarNames.CONNECTION_ID: connection_id,
228			VarNames.USER_ID: self.user_id,
229			VarNames.USER: self.sender_name,
230			VarNames.WEBRTC_OPPONENT_ID: self.id,
231			VarNames.HANDLER_NAME: HandlerNames.WEBRTC_TRANSFER,
232			}

Deathangel908 / pychat

Push — master ( 7365f5...41cb1b )

WebRtcMessageCreator.__init__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

WebRtcMessageCreator.init() A