MessagesCreator.prepare_img_video() - Code Metrics - Deathangel908/pychat - Measure and Improve Code Quality continuously with Scrutinizer

MessagesCreator.prepare_img_video() A
last analyzed 2018-07-01 16:09 UTC

↳ Parent: MessagesCreator

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
c	0
b	0
f	0
dl	0
loc	13
rs	9.2833

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


class MessagesCreator(object):

	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 base_default(event, content, handler):
		return {
			VarNames.EVENT: event,
			VarNames.CONTENT: content,
			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
		}

	@classmethod
	def set_room(cls, rooms, users, online):
		res = cls.base_default(Actions.ROOMS, rooms, HandlerNames.CHANNELS)
		res[VarNames.ROOM_USERS] = users
		res[VarNames.ONLINE] = online
		return res

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

	@classmethod
	def create_message(cls, message, files):
		res = {
			VarNames.USER_ID: message.sender_id,
			VarNames.CONTENT: message.content,
			VarNames.TIME: message.time,
			VarNames.MESSAGE_ID: message.id,
			VarNames.EDITED_TIMES: message.edited_times,
			VarNames.ROOM_ID: message.room_id,
		}
		if message.deleted:
			res[VarNames.DELETED] = True
		if files:
			res[VarNames.FILES] = files
		if message.symbol:
			res[VarNames.SYMBOL] = message.symbol
		if message.giphy:
			res[VarNames.GIPHY] = message.giphy
		return res

	@classmethod
	def create_send_message(cls, message, event, files, js_id):
		"""
		: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, files)
		res[VarNames.EVENT] = event
		res[VarNames.JS_MESSAGE_ID] = js_id
		res[VarNames.HANDLER_NAME] = HandlerNames.CHAT
		return res

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

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

	@staticmethod
	def ping_client(time):
		return {
			VarNames.EVENT: Actions.PING,
			VarNames.TIME: time,
			VarNames.HANDLER_NAME: HandlerNames.WS,
		}

	@staticmethod
	def prepare_img_video(files, message_id):
		"""
		:type message_id: int
		:type files: list[chat.models.Image]
		"""
		if files:
			return {x.symbol: {
				VarNames.FILE_URL: x.img.url,
				VarNames.FILE_TYPE: x.type,
				VarNames.PREVIEW: x.preview.url if x.preview else None,
				VarNames.IMAGE_ID: x.id
			} for x in files if x.message_id == message_id}

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

	def subscribe_direct_channel_message(self, room_id, users_id, notifications):
		return {
			VarNames.EVENT: Actions.CREATE_DIRECT_CHANNEL,
			VarNames.VOLUME: 2,
			VarNames.NOTIFICATIONS: notifications,
			VarNames.ROOM_ID: room_id,
			VarNames.TIME: get_milliseconds(),
			VarNames.ROOM_USERS: users_id,
			VarNames.HANDLER_NAME: HandlerNames.CHANNELS
		}

	def responde_pong(self, js_id):
		return {
			VarNames.EVENT: Actions.PONG,
			VarNames.HANDLER_NAME: HandlerNames.WS,
			VarNames.JS_MESSAGE_ID: js_id
		}

	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.VOLUME: 2,
			VarNames.NOTIFICATIONS: True,
			VarNames.ROOM_NAME: room_name
		}

	@staticmethod
	def add_user_to_room(channel, channel_name, inviter, invitee, all_users):
		return {
			VarNames.EVENT: Actions.INVITE_USER,
			VarNames.ROOM_ID: channel,
			VarNames.ROOM_NAME: channel_name,
			VarNames.INVITEE_USER_ID: invitee,
			VarNames.INVITER_USER_ID: inviter,
			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
			VarNames.ROOM_USERS: all_users,
			VarNames.TIME: get_milliseconds(),
		}

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

	@staticmethod
	def create_user_rooms(user_rooms):
		res = {room['id']: {
			VarNames.ROOM_NAME: room['name'],
			VarNames.NOTIFICATIONS: room['roomusers__notifications'],
			VarNames.VOLUME: room['roomusers__volume'],
			VarNames.ROOM_USERS: []
		} for room in user_rooms}
		return res


class WebRtcMessageCreator(object):

	def offer_webrtc(self, content, connection_id, room_id, action):
		"""
		:return: {"action": "call", "content": content, "time": "20:48:57"}
		"""
		return {
			VarNames.EVENT: action,
			VarNames.CONTENT: content,
			VarNames.USER_ID: self.user_id,
			VarNames.HANDLER_NAME: HandlerNames.WEBRTC,
			VarNames.USER: self.sender_name,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.WEBRTC_OPPONENT_ID: self.id,
			VarNames.ROOM_ID: room_id
		}

	def set_webrtc_error(self, error, connection_id, qued_id=None):
		return {
			VarNames.EVENT: Actions.SET_WEBRTC_ERROR,
			VarNames.CONTENT: error,
			VarNames.USER_ID: self.user_id,
			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.WEBRTC_QUED_ID: qued_id
		}

	@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_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, content):
		return {
			VarNames.EVENT: Actions.ACCEPT_FILE,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.WEBRTC_OPPONENT_ID: self.id,
			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
			VarNames.CONTENT: content,
		}

	def reply_webrtc(self, event, connection_id, handler, content):
		return {
			VarNames.EVENT: event,
			VarNames.CONNECTION_ID: connection_id,
			VarNames.USER_ID: self.user_id,
			VarNames.USER: self.sender_name,
			VarNames.CONTENT: content,
			VarNames.WEBRTC_OPPONENT_ID: self.id,
			VarNames.HANDLER_NAME: handler,
		}

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


1			from chat.models import get_milliseconds
2			from chat.tornado.constants import VarNames, HandlerNames, Actions, RedisPrefix
3
4
5			class MessagesCreator(object):
6
7			def default(self, content, event, handler):
8			"""
9			:return: {"action": event, "content": content, "time": "20:48:57"}
10			"""
11			return {
12			VarNames.EVENT: event,
13			VarNames.CONTENT: content,
14			VarNames.USER_ID: self.user_id,
15			VarNames.TIME: get_milliseconds(),
16			VarNames.HANDLER_NAME: handler
17			}
18
19			@staticmethod
20			def base_default(event, content, handler):
21			return {
22			VarNames.EVENT: event,
23			VarNames.CONTENT: content,
24			VarNames.HANDLER_NAME: handler
25			}
26
27			@staticmethod
28			def set_ws_id(random, self_id):
29			return {
30			VarNames.HANDLER_NAME: HandlerNames.WS,
31			VarNames.EVENT: Actions.SET_WS_ID,
32			VarNames.CONTENT: random,
33			VarNames.WEBRTC_OPPONENT_ID: self_id
34			}
35
36			@classmethod
37			def set_room(cls, rooms, users, online):
38			res = cls.base_default(Actions.ROOMS, rooms, HandlerNames.CHANNELS)
39			res[VarNames.ROOM_USERS] = users
40			res[VarNames.ONLINE] = online
41			return res
42
43			def room_online(self, online, event):
44			"""
45			:return: {"action": event, "content": content, "time": "20:48:57"}
46			"""
47			room_less = self.default(online, event, HandlerNames.CHANNELS)
48			room_less[VarNames.USER] = self.sender_name
49			room_less[VarNames.GENDER] = self.sex
50			return room_less
51
52			@classmethod
53			def create_message(cls, message, files):
54			res = {
55			VarNames.USER_ID: message.sender_id,
56			VarNames.CONTENT: message.content,
57			VarNames.TIME: message.time,
58			VarNames.MESSAGE_ID: message.id,
59			VarNames.EDITED_TIMES: message.edited_times,
60			VarNames.ROOM_ID: message.room_id,
61			}
62			if message.deleted:
63			res[VarNames.DELETED] = True
64			if files:
65			res[VarNames.FILES] = files
66			if message.symbol:
67			res[VarNames.SYMBOL] = message.symbol
68			if message.giphy:
69			res[VarNames.GIPHY] = message.giphy
70			return res
71
72			@classmethod
73			def create_send_message(cls, message, event, files, js_id):
74			"""
75			:type message: chat.models.Message
76			:type imgs: dict
77			:type event: Actions
78			:return: "action": "joined", "content": {"v5bQwtWp": "alien", "tRD6emzs": "Alien"},
79			"sex": "Alien", "user": "tRD6emzs", "time": "20:48:57"}
80			"""
81			res = cls.create_message(message, files)
82			res[VarNames.EVENT] = event
83			res[VarNames.JS_MESSAGE_ID] = js_id
84			res[VarNames.HANDLER_NAME] = HandlerNames.CHAT
85			return res
86
87			@classmethod
88			def append_images(cls, messages, files, prepare_img):
89			"""
90			:type messages: list[chat.models.Message]
91			:type files: list[chat.models.Image]
92			"""
93			res_mess = []
94			for message in messages:
95			res_mess.append(cls.create_message(message, prepare_img(files, message.id)))
96			return res_mess
97
98			@classmethod
99			def get_messages(cls, messages, channel, files, prepare_img):
100			"""
101			:type images: list[chat.models.Image]
102			:type messages: list[chat.models.Message]
103			:type channel: str
104			"""
105			return {
106			VarNames.CONTENT: cls.append_images(messages, files, prepare_img),
107			VarNames.EVENT: Actions.GET_MESSAGES,
108			VarNames.ROOM_ID: channel,
109			VarNames.HANDLER_NAME: HandlerNames.CHAT
110			}
111
112			@staticmethod
113			def ping_client(time):
114			return {
115			VarNames.EVENT: Actions.PING,
116			VarNames.TIME: time,
117			VarNames.HANDLER_NAME: HandlerNames.WS,
118			}
119
120			@staticmethod
121			def prepare_img_video(files, message_id):
122			"""
123			:type message_id: int
124			:type files: list[chat.models.Image]
125			"""
126			if files:
127			return {x.symbol: {
128			VarNames.FILE_URL: x.img.url,
129			VarNames.FILE_TYPE: x.type,
130			VarNames.PREVIEW: x.preview.url if x.preview else None,
131			VarNames.IMAGE_ID: x.id
132			} for x in files if x.message_id == message_id}
133
134			@property
135			def channel(self):
136			return RedisPrefix.generate_user(self.user_id)
137
138			def subscribe_direct_channel_message(self, room_id, users_id, notifications):
139			return {
140			VarNames.EVENT: Actions.CREATE_DIRECT_CHANNEL,
141			VarNames.VOLUME: 2,
142			VarNames.NOTIFICATIONS: notifications,
143			VarNames.ROOM_ID: room_id,
144			VarNames.TIME: get_milliseconds(),
145			VarNames.ROOM_USERS: users_id,
146			VarNames.HANDLER_NAME: HandlerNames.CHANNELS
147			}
148
149			def responde_pong(self, js_id):
150			return {
151			VarNames.EVENT: Actions.PONG,
152			VarNames.HANDLER_NAME: HandlerNames.WS,
153			VarNames.JS_MESSAGE_ID: js_id
154			}
155
156			def subscribe_room_channel_message(self, room_id, room_name):
157			return {
158			VarNames.EVENT: Actions.CREATE_ROOM_CHANNEL,
159			VarNames.ROOM_ID: room_id,
160			VarNames.ROOM_USERS: [self.user_id],
161			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
162			VarNames.VOLUME: 2,
163			VarNames.NOTIFICATIONS: True,
164			VarNames.ROOM_NAME: room_name
165			}
166
167			@staticmethod
168			def add_user_to_room(channel, channel_name, inviter, invitee, all_users):
169			return {
170			VarNames.EVENT: Actions.INVITE_USER,
171			VarNames.ROOM_ID: channel,
172			VarNames.ROOM_NAME: channel_name,
173			VarNames.INVITEE_USER_ID: invitee,
174			VarNames.INVITER_USER_ID: inviter,
175			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
176			VarNames.ROOM_USERS: all_users,
177			VarNames.TIME: get_milliseconds(),
178			}
179
180			def unsubscribe_direct_message(self, room_id, room_user_ids, room_name):
181			return {
182			VarNames.EVENT: Actions.DELETE_ROOM,
183			VarNames.ROOM_ID: room_id,
184			VarNames.USER_ID: self.user_id,
185			VarNames.HANDLER_NAME: HandlerNames.CHANNELS,
186			VarNames.ROOM_USERS: room_user_ids,
187			VarNames.ROOM_NAME: room_name,
188			VarNames.TIME: get_milliseconds()
189			}
190
191			@staticmethod
192			def create_user_rooms(user_rooms):
193			res = {room['id']: {
194			VarNames.ROOM_NAME: room['name'],
195			VarNames.NOTIFICATIONS: room['roomusers__notifications'],
196			VarNames.VOLUME: room['roomusers__volume'],
197			VarNames.ROOM_USERS: []
198			} for room in user_rooms}
199			return res
200
201
202			class WebRtcMessageCreator(object):
203
204			def offer_webrtc(self, content, connection_id, room_id, action):
205			"""
206			:return: {"action": "call", "content": content, "time": "20:48:57"}
207			"""
208			return {
209			VarNames.EVENT: action,
210			VarNames.CONTENT: content,
211			VarNames.USER_ID: self.user_id,
212			VarNames.HANDLER_NAME: HandlerNames.WEBRTC,
213			VarNames.USER: self.sender_name,
214			VarNames.CONNECTION_ID: connection_id,
215			VarNames.WEBRTC_OPPONENT_ID: self.id,
216			VarNames.ROOM_ID: room_id
217			}
218
219			def set_webrtc_error(self, error, connection_id, qued_id=None):
220			return {
221			VarNames.EVENT: Actions.SET_WEBRTC_ERROR,
222			VarNames.CONTENT: error,
223			VarNames.USER_ID: self.user_id,
224			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
225			VarNames.CONNECTION_ID: connection_id,
226			VarNames.WEBRTC_QUED_ID: qued_id
227			}
228
229			@staticmethod
230			def set_connection_id(qued_id, connection_id):
231			return {
232			VarNames.EVENT: Actions.SET_WEBRTC_ID,
233			VarNames.HANDLER_NAME: HandlerNames.WEBRTC,
234			VarNames.CONNECTION_ID: connection_id,
235			VarNames.WEBRTC_QUED_ID: qued_id
236			}
237
238			def get_close_file_sender_message(self, connection_id):
239			return {
240			VarNames.EVENT: Actions.CLOSE_FILE_CONNECTION,
241			VarNames.CONNECTION_ID: connection_id,
242			VarNames.WEBRTC_OPPONENT_ID: self.id,
243			VarNames.HANDLER_NAME: HandlerNames.WEBRTC_TRANSFER,
244			}
245
246			def get_accept_file_message(self, connection_id, content):
247			return {
248			VarNames.EVENT: Actions.ACCEPT_FILE,
249			VarNames.CONNECTION_ID: connection_id,
250			VarNames.WEBRTC_OPPONENT_ID: self.id,
251			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
252			VarNames.CONTENT: content,
253			}
254
255			def reply_webrtc(self, event, connection_id, handler, content):
256			return {
257			VarNames.EVENT: event,
258			VarNames.CONNECTION_ID: connection_id,
259			VarNames.USER_ID: self.user_id,
260			VarNames.USER: self.sender_name,
261			VarNames.CONTENT: content,
262			VarNames.WEBRTC_OPPONENT_ID: self.id,
263			VarNames.HANDLER_NAME: handler,
264			}
265
266			def retry_file(self, connection_id):
267			return {
268			VarNames.EVENT: Actions.RETRY_FILE_CONNECTION,
269			VarNames.CONNECTION_ID: connection_id,
270			VarNames.WEBRTC_OPPONENT_ID: self.id,
271			VarNames.HANDLER_NAME: HandlerNames.PEER_CONNECTION,
272			}
273

Deathangel908 / pychat

MessagesCreator.prepare_img_video() A last analyzed 2018-07-01 16:09 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

MessagesCreator.prepare_img_video() A
last analyzed 2018-07-01 16:09 UTC