def test_update_media_data(self):
media_id = '12345678'
media_title = 'Тест 1'
new_label = 'Тест 2'
command_data = {
'client_id': self.test_context.admin_id,
'kinopoisk_id': media_id,
'label': media_title,
'year': 1999,
'url': 'http://test1'
}
self.test_context.add_test_film(self.db.session, **command_data)
data = {
'media_id': media_id,
'media_type': app_enums.MediaType.FILMS,
'upd_data': {
'label': new_label
}
}
command = app_enums.ClientCommands.UPDATE_MEDIA
command_msg = command_message(app_enums.ComponentType.MAIN_APP,
command, data, self.client_id)
self.test_handler.handle_message(command_msg)
media = self.db.find_media(media_id, app_enums.MediaType.FILMS)
self.assertTrue(media.title == new_label,
'Наименование не изменилось.')
def test_add_media_to_user(self):
media_id = '12345678'
media_title = 'Тест 1'
client_id = 1225
film = self.test_context.add_test_film(
self.db.session, **{
'client_id': self.test_context.admin_id,
'kinopoisk_id': media_id,
'label': media_title,
'year': 1999,
'url': 'http://test1'
})
user = self.db.add_user(client_id, '', '', '')
data = {
'kinopoisk_id': media_id,
'media_type': app_enums.MediaType.FILMS,
'season': 0
}
command_msg = command_message(
app_enums.ComponentType.CLIENT,
app_enums.ClientCommands.ADD_MEDIA_TO_USER_LIST, data, client_id)
self.test_handler.handle_message(command_msg)
self.assertIn(str(film.kinopoisk_id),
[a.kinopoisk_id for a in user.media.all()],
'Фильм не добавлен пользователю')
def auth_query(cls, data: CommandData, db_manager: DbManager, config):
"""
Query for authentication from new user/
:param data:
:param db_manager:
:return:
"""
messages = []
session = db_manager.get_session()
if db_manager.is_admin(data.client_id):
messages.append(
command_message(
ComponentType.COMMAND_HANDLER,
ClientCommands.ADD_DATA_USER,
{
'client_id': data.command_data['client_id'],
'name': data.command_data['name'],
'last_name': data.command_data['last_name'],
'nick': data.command_data['nick']
},
data.client_id
)
)
else:
message_text = 'У тебя нет прав на добавление пользователей.'
messages.append(
send_message(
ComponentType.COMMAND_HANDLER,
{
'user_id': data.client_id, 'message_text': message_text, 'choices': []
}
)
)
session.close()
return messages
def end_chain(self, data):
text_type = 'Фильм' if data.data[
'media_type'].value == MediaType.FILMS.value else 'Сериал'
title = data.data['title']
if data.data['media_status'] != LockingStatus.ENDED:
message_text = f'{text_type} {title} уже ищется.'
else:
message_text = f'Поиск {text_type}а по запросу {title} завершен.'
self.messages.append(
send_message(
ComponentType.PARSER, {
'user_id': data.client_id,
'message_text': message_text,
'choices': []
}))
self.messages.append(
command_message(
ComponentType.PARSER,
ClientCommands.ADD_MEDIA_TO_USER_LIST,
{
'kinopoisk_id':
data.data['kinopoisk_id'],
'media_type':
MediaType.FILMS if 'serial' in data.data.keys()
and not data.data['serial'] else MediaType.SERIALS,
'season':
data.data['season'] if 'season' in data.data.keys() else 0,
},
data.client_id,
))
return self.messages
def end_chain(self, data: ParserData) -> list:
command = ClientCommands.ADD_DATA_FILM if 'serial' in data.data.keys() and \
not data.data['serial'] else ClientCommands.ADD_DATA_SERIAL
self.messages.append(
command_message(ComponentType.PARSER, command, data.data,
data.client_id))
return self.messages
def test_command_add_serial(self):
self.mediator.start()
self.parser.start()
self.test_handler.start()
command_data = dict(text='Игра')
command = app_enums.ClientCommands.ADD_SERIAL
command_msg = command_message(app_enums.ComponentType.MAIN_APP,
command, command_data, self.client_id)
self.test_handler.handle_message(command_msg)
def test_command_change_notification(self):
notif_option = app_enums.UserOptions.NOTIFICATION
command_data = {'option': notif_option}
command = app_enums.ClientCommands.EDIT_SETTINGS
command_msg = command_message(app_enums.ComponentType.MAIN_APP,
command, command_data, self.client_id)
self.test_handler.handle_message(command_msg)
val = self.db.get_user_option(self.client_id, notif_option)
self.assertTrue(val == 1, 'Статус не изменился')
def start_torrent_watcher_message(job, data) -> MediatorMessage:
upd_data = {'torrent_id': data['torrent_id']}
command_data = construct_upd_data(job, upd_data)
data = {}
add_media_keys(job, data)
command_data.update({
'next_messages': [
crawler_message(ComponentType.COMMAND_HANDLER, job.client_id, data,
ActionType.ADD_TORRENT_WATCHER)
]
})
return command_message(ComponentType.CRAWLER, ClientCommands.UPDATE_MEDIA,
command_data, job.client_id)
def test_add_user(self):
new_user_id = 12345
data = {
'client_id': new_user_id,
'name': 'Al',
'last_name': 'Al',
'nick': 'Al'
}
command_msg = command_message(app_enums.ComponentType.CLIENT,
app_enums.ClientCommands.ADD_DATA_USER,
data, self.client_id)
self.test_handler.handle_message(command_msg)
new_user = self.db.find_user(new_user_id)
self.assertIsNotNone(new_user, 'Новый пользователь не создан.')
def handle_user(self, user_id):
try:
client_data = self.bot.get_chat(user_id)
data = {
'client_id': self.user_id,
'name': client_data.first_name,
'last_name': client_data.last_name,
'nick': client_data.username
}
except teleg_error.BadRequest:
data = {
'client_id': self.user_id,
'name': '',
'last_name': '',
'nick': ''
}
self.bot.protocol.send_message(
command_message(ComponentType.CLIENT,
ClientCommands.AUTHENTICATION, data, self.user_id))
def get_callback_message(cls, cache_data, update):
message = None
if 'force' in cache_data.keys():
cache_data['key_board'] = False
message = crawler_message(ComponentType.CLIENT,
update.callback_query.from_user.id,
cache_data,
ActionType.ADD_TORRENT_WATCHER)
elif 'action' in cache_data.keys():
if cache_data['action'] == 'kinopoisk':
message = parser_message(ComponentType.CLIENT, cache_data,
update.callback_query.from_user.id)
elif cache_data['action'] == 'select_torrent':
client_id = update.callback_query.from_user.id
command_data = {
'media_id': cache_data['media_id'],
'media_type': cache_data['media_type'],
}
upd_data = {
'download_url': cache_data['download_url'],
'theam_id': cache_data['theam_id'],
'torrent_tracker': cache_data['torrent_tracker'],
}
if cache_data['media_type'].value == MediaType.SERIALS.value:
season = {'season': cache_data['season']}
command_data.update(season)
command_data.update({
'upd_data':
upd_data,
'next_messages': [
crawler_message(ComponentType.CRAWLER, client_id,
cache_data,
ActionType.DOWNLOAD_TORRENT)
]
})
message = command_message(ComponentType.CRAWLER,
ClientCommands.UPDATE_MEDIA,
command_data, client_id)
return message
def film_success_message(data, job):
dwld_data = {}
add_media_keys(job, dwld_data)
upd_data = {
'download_url': data.url,
'theam_id': data.theam_url,
'torrent_tracker': data.tracker,
}
command_data = construct_upd_data(job, upd_data)
command_data.update({
'next_messages': [
crawler_message(ComponentType.CRAWLER, job.client_id, dwld_data,
ActionType.DOWNLOAD_TORRENT)
],
})
return command_message(ComponentType.CRAWLER, ClientCommands.UPDATE_MEDIA,
command_data, job.client_id)
def get_command_message(cls, command: str, data: dict, chat_id: int):
"""
Send message to command exsecuter
:param command:
:param data:
:param chat_id:
:return:
"""
client_command = [
x['command'] for x in cls.message_commands()
if x['command_text'] == command
]
client_command = client_command[0] if len(client_command) else None
if client_command is None:
logging.error('Wrong command for execution {0}'.format(command))
return
return command_message(ComponentType.CLIENT, client_command, data,
chat_id)
def test_command_send_messages(self):
media_id = '12345678'
media_title = 'Тест 1'
self.test_context.add_test_film(
self.db.session, **{
'client_id': self.test_context.admin_id,
'kinopoisk_id': media_id,
'label': media_title,
'year': 1999,
'url': 'http://test1'
})
data = {
'client_id': self.test_context.admin_id,
'message_text': media_title,
'choices': []
}
comm_message = command_message(app_enums.ComponentType.MAIN_APP,
app_enums.ClientCommands.SEND_MESSAGES,
data, self.test_context.admin_id)
self.test_handler.handle_message(comm_message)
def watcher_messages(job, data):
messages = []
torrent_inform = data['torrent_information']
if torrent_inform['progress'] == 100:
message_text = 'Скачивание {} завершено, беги скорей на плекс.'.format(
job.text_query)
choices = []
messages += [
command_message(ComponentType.CRAWLER,
ClientCommands.UPDATE_PLEX_LIB, {}, job.client_id)
]
else:
message_text = 'Прогресс скачивания {0}: {1}% {2}/{3}'.format(
job.text_query,
torrent_inform['progress'],
convert_size(torrent_inform['total_done']),
convert_size(torrent_inform['total_size']),
)
if 'key_board' in job.crawler_data.data.keys(
) and not job.crawler_data.data['key_board']:
choices = []
else:
data = {}
add_media_keys(job, data)
data.update({
'force': True,
})
choices = {'action': 'download_callback', 'data': data}
messages.append(
send_message(
ComponentType.CRAWLER, {
'user_id': job.client_id,
'message_text': message_text,
'choices': choices
}))
return messages
def handle_serial(self, query):
message = command_message(ComponentType.CLIENT,
ClientCommands.ADD_SERIAL, {'text': query},
self.user_id)
self.bot.protocol.send_message(message)
def construct_messages(self, data):
messages = []
for torrent_data in data:
media = self.job
if media.media_type.value == MediaType.FILMS.value:
message_text = 'Фильм "{0}" будет скачан, через несколько минут. \n {1}'.format(
media.text_query,
media.kinopoisk_url
)
status = LockingStatus.ENDED
else:
message_text = 'Новая серия "{0}" будет скачана, через несколько минут. \n {1}'.format(
media.text_query,
media.kinopoisk_url
)
if self.job.current_series == torrent_data['file_amount']:
return []
if self.job.series != 0 and torrent_data['file_amount'] >= self.job.series:
status = LockingStatus.ENDED
else:
status = LockingStatus.FIND_TORRENT
upd_data = {
'status': status,
'exsists_in_plex': True,
'current_series': 0 if media.season == '' else torrent_data['file_amount']
}
command_data = construct_upd_data(media, upd_data)
send_data = {
'choices': [],
'message_text': message_text
}
add_media_keys(media, send_data)
add_torrent_data = {
'torrent_id': torrent_data['id'],
'torrent_data': torrent_data['data'],
}
add_media_keys(media, add_torrent_data)
messages += [
command_message(
ComponentType.CRAWLER,
ClientCommands.UPDATE_MEDIA,
command_data,
self.job.client_id
),
crawler_message(
ComponentType.CRAWLER,
media.client_id,
add_torrent_data,
ActionType.ADD_TORRENT_TO_TORRENT_CLIENT
),
command_message(
ComponentType.CRAWLER,
ClientCommands.SEND_MESSAGES_BY_MEDIA,
send_data,
self.job.client_id
)
]
return messages
