result = _addon.getSetting(id)

if result != '':

return result

else:

base_path = getSetting('base_path', '').decode('utf-8')

if base_path == u'Videos':

base_path = filesystem.join(_addondir, base_path)

movies_path = getSetting('movies_path', 'Movies').decode('utf-8')

animation_path = getSetting('animation_path', 'Animation').decode('utf-8')

documentary_path = getSetting('documentary_path', 'Documentary').decode('utf-8')

anime_path = getSetting('anime_path', 'Anime').decode('utf-8')

from settings import Settings

settings = Settings(base_path,

movies_path = movies_path,

animation_path = animation_path,

documentary_path = documentary_path,

anime_path = anime_path

)

settings.hdclub_passkey = getSetting('hdclub_passkey')

settings.bluebird_login = getSetting('bluebird_login')

settings.bluebird_password = getSetting('bluebird_password')

settings.bluebird_nouhd = getSetting('bluebird_nouhd')

settings.anidub_login = getSetting('anidub_login')

settings.anidub_password = getSetting('anidub_password')

settings.anidub_rss = getSetting('anidub_rss')

settings.anidub_favorite = getSetting('anidub_favorite')

settings.nnmclub_pages = 3

settings.nnmclub_login = getSetting('nnmclub_login')

settings.nnmclub_password = getSetting('nnmclub_password')

settings.nnmclub_domain = getSetting('nnmclub_domain')

settings.nnmclub_use_ssl = getSetting('nnmclub_use_ssl') == 'true'

settings.rutor_domain = getSetting('rutor_domain')

settings.rutor_filter = getSetting('rutor_filter')

settings.soap4me_login = getSetting('soap4me_login')

settings.soap4me_password = getSetting('soap4me_password')

settings.soap4me_rss = getSetting('soap4me_rss')

settings.preffered_bitrate = int(getSetting('preffered_bitrate'))

settings.preffered_type = getSetting('preffered_type')

settings.preffered_codec = getSetting('preffered_codec')

settings.torrent_player = getSetting('torrent_player')

settings.storage_path = getSetting('storage_path')

settings.movies_save = getSetting('movies_save') == 'true'

settings.animation_save = getSetting('animation_save') == 'true'

settings.documentary_save = getSetting('documentary_save') == 'true'

settings.anime_save = getSetting('anime_save') == 'true'

settings.tvshows_save = getSetting('tvshows_save') == 'true'

settings.animation_tvshows_save = getSetting('animation_tvshows_save') == 'true'

settings.torrent_path = getSetting('torrent_path')

settings.rutor_nosd = getSetting('rutor_nosd') == 'true'

settings.addon_data_path = _addondir

if getSetting('data_path'):

settings.addon_data_path = getSetting('data_path')

settings.run_script = getSetting('run_script') == 'true'

settings.script_params = getSetting('script_params').decode('utf-8')

settings.remeber_watched = getSetting('remeber_watched') == 'true'

settings.move_video = getSetting('action_files').decode('utf-8') == u'переместить'

settings.remove_files = getSetting('action_files').decode('utf-8') == u'удалить'

settings.copy_video_path = getSetting('copy_video_path').decode('utf-8')

settings.copy_torrent = getSetting('copy_torrent') == 'true'

settings.copy_torrent_path = getSetting('copy_torrent_path').decode('utf-8')

settings.use_kinopoisk = getSetting('use_kinopoisk') == 'true'

settings.use_worldart = getSetting('use_worldart') == 'true'

settings.kp_googlecache = getSetting('kp_googlecache') == 'true'

settings.kp_usezaborona = getSetting('kp_usezaborona') == 'true'

settings.show_sources = getSetting('show_sources') == 'true'

settings.skip_show_sources = getSetting('skip_show_sources') == 'true'

settings.kinohd_enable = getSetting('kinohd_enable') == 'true'

settings.kinohd_4k = getSetting('kinohd_4k') == 'true'

settings.kinohd_1080p = getSetting('kinohd_1080p') == 'true'

settings.kinohd_720p = getSetting('kinohd_720p') == 'true'

settings.kinohd_3d = getSetting('kinohd_3d') == 'true'

settings.kinohd_serial = getSetting('kinohd_serial') == 'true'

#import filecmp

def _debug(msg):

try:

if isinstance(msg, str):

msg = msg.decode('utf-8')

debug(u'play_torrent_variant: {}'.format(msg) )

except:

debug('_debug raised exception')

play_torrent_variant. resultOK = 'OK'

play_torrent_variant. resultCancel = 'Cancel'

play_torrent_variant. resultTryNext = 'TryNext'

play_torrent_variant. resultTryAgain = 'TryAgain'

start_time = time.time()

start_play_max_time = int(_addon.getSetting( 'start_play_max_time')) # default 60 seconds

search_seed_max_time = int(_addon.getSetting('search_seed_max_time')) # default 15 seconds

if episodeNumber != None:

episodeNumber = int(episodeNumber)

if settings == None:

return play_torrent_variant.resultCancel

if downloader:

try:

downloader.start(True)

except:

print_tb()

torrent_info = None

torrent_path = path

xbmc_player = None

if 'kinohd' in path:

kinohd_torrent_player = getSetting('kinohd_torrent_player')

if kinohd_torrent_player and kinohd_torrent_player != 'Default':

settings.torrent_player = kinohd_torrent_player

from torrent2http import Error as TPError

try:

if settings.torrent_player == 'YATP':

from yatpplayer import YATPPlayer

player = YATPPlayer()

elif settings.torrent_player == 'torrent2http':

from torrent2httpplayer import Torrent2HTTPPlayer

player = Torrent2HTTPPlayer(settings)

elif settings.torrent_player == 'Ace Stream':

import aceplayer

player = aceplayer.AcePlayer(settings)

elif settings.torrent_player == 'Elementum':

import elementumplayer

player = elementumplayer.ElementumPlayer()

elif settings.torrent_player == 'TorrServer':

import torrserverplayer

player = torrserverplayer.TorrServerPlayer(settings)

_debug('------------ Open torrent: ' + path)

player.AddTorrent(path)

added = False

for i in range(start_play_max_time):

if player.CheckTorrentAdded():

added = True

break

if xbmc.abortRequested:

return play_torrent_variant.resultCancel

info_dialog.update(i, u'Проверяем файлы', ' ', ' ')

if downloader and downloader.is_finished():

#if not filecmp.cmp(path, downloader.get_filename()):

if downloader.info_hash() and downloader.info_hash() != player.info_hash:

downloader.move_file_to(path)

_debug('play_torrent_variant.resultTryAgain')

return play_torrent_variant.resultTryAgain

else:

_debug('Torrents are equal')

downloader = None

xbmc.sleep(1000)

if not added:

_debug('Torrent not added')

return play_torrent_variant.resultTryNext

files = player.GetLastTorrentData()['files']

#_debug(files)

if 'cutName' not in params:

if 'index' not in params:

if episodeNumber is not None:

files.sort(key=operator.itemgetter('name'))

else:

files.sort(key=operator.itemgetter('size'), reverse=True)

#_debug('sorted_files:')

#_debug(files)

try:

if 'cutName' not in params:

if 'index' not in params:

if episodeNumber is None:

index = 0

playable_item = files[0]

else:

playable_item = files[episodeNumber]

index = playable_item.get('index')

else:

index = -1

for item in files:

if int(params['index']) == item['index']:

playable_item = item

index = playable_item.get('index')

else:

cutName = urllib.unquote(params['cutName']).decode('utf-8').lower()

index = -1

for item in files:

name = item['name'].lower()

from tvshowapi import cutStr

if cutName in unicode(cutStr(name)):

playable_item = item

index = playable_item.get('index')

break

if index == -1:

return play_torrent_variant.resultTryNext

except IndexError:

for i in range(10):

if downloader and downloader.is_finished():

#if not filecmp.cmp(path, downloader.get_filename()):

if downloader.info_hash() and downloader.info_hash() != player.info_hash:

downloader.move_file_to(path)

print 'play_torrent_variant.resultTryAgain'

return play_torrent_variant.resultTryAgain

xbmc.sleep(1000)

_debug(playable_item)

player.StartBufferFile(index)

if not player.CheckTorrentAdded():

info_dialog.update(0, 'Media Aggregator: проверка файлов')

while not info_dialog.iscanceled() and not player.CheckTorrentAdded():

xbmc.sleep(1000)

start_time = time.time()

player.updateCheckingProgress(info_dialog)

info_dialog.update(0, 'Media Aggregator: буфферизация')

while not info_dialog.iscanceled():

if player.CheckBufferComplete():

break

percent = player.GetBufferingProgress()

if percent >= 0:

player.updateDialogInfo(percent, info_dialog)

if time.time() > start_time + start_play_max_time:

return play_torrent_variant.resultTryNext

if time.time() > start_time + search_seed_max_time:

info = player.GetTorrentInfo()

if 'num_seeds' in info:

if info['num_seeds'] == 0:

_debug('Seeds not found')

return play_torrent_variant.resultTryNext

if downloader and downloader.is_finished():

#if not filecmp.cmp(path, downloader.get_filename()):

if downloader.info_hash() and downloader.info_hash() != player.info_hash:

downloader.move_file_to(path)

_debug('play_torrent_variant.resultTryAgain')

return play_torrent_variant.resultTryAgain

else:

_debug('Torrents are equal')

downloader = None

xbmc.sleep(1000)

canceled = info_dialog.iscanceled()

info_dialog.update(0)

info_dialog.close()

if canceled:

return play_torrent_variant.resultCancel

playable_url = player.GetStreamURL(playable_item)

_debug(playable_url)

handle = int(sys.argv[1])

if nfoReader != None:

list_item = nfoReader.make_list_item(playable_url)

else:

list_item = xbmcgui.ListItem(path=playable_url)

_debug('ListItem created')

rel_path = urllib.unquote(params['path']).decode('utf-8')

filename = urllib.unquote(params['nfo']).decode('utf-8')

from kodidb import KodiDB

k_db = KodiDB(filename.replace(u'.nfo', u'.strm'), \

rel_path,

sys.argv[0] + sys.argv[2])

k_db.PlayerPreProccessing()

_debug('VideoDB PreProccessing: OK')

class OurPlayer(xbmc.Player):

def __init__(self):

xbmc.Player.__init__(self)

self.show_overlay = False

self.time_started = time.time()

self.download_started = None

self.fs_video = xbmcgui.Window(12005)

x = 20

y = int(getSetting('dnl_progress_offset', 120))

w = self.fs_video.getWidth()

h = 130

self.info_label = xbmcgui.ControlLabel(x, y, w, h, '', textColor='0xFF00EE00', font='font16')

self.info_label_bg = xbmcgui.ControlLabel(x+2, y+2, w, h, '', textColor='0xAA000000', font='font16')

def _show_progress(self):

if settings.torrent_player == 'Ace Stream':

return

if settings.torrent_player == 'Elementum':

return

if getSetting('show_dnl_progress', 'true') != 'true':

return

if not self.show_overlay:

_debug('addControls')

self.fs_video.addControls([self.info_label_bg, self.info_label])

self.show_overlay = True

def _hide_progress(self):

if self.show_overlay:

_debug('removeControls')

self.info_label.setLabel('')

self.info_label_bg.setLabel('')

self.fs_video.removeControls([self.info_label_bg, self.info_label])

self.show_overlay = False

def UpdateProgress(self):

if self.show_overlay:

info = player.GetTorrentInfo()

percent = float(info['downloaded']) * 100 / info['size']

if percent >= 0:

heading = u"{} МB из {} МB - {}".format(info['downloaded'], info['size'], int(percent)) + r'%' + '\n'

if percent < 100:

heading += u"Скорость загрузки: {} KB/сек\n".format(info['dl_speed'])

this_time = time.time()

time_passed = (this_time - self.time_started)

if time_passed > 10:

if not self.download_started:

self.download_started = info['downloaded']

average_speed = float((info['downloaded'] - self.download_started) / (time_passed - 10))

seconds = (info['size'] - info['downloaded']) / average_speed if average_speed != 0 else -1

# _debug('seconds: {}'.format(seconds))

if seconds > 0:

heading += u"Осталось: {} мин {} сек\n".format(int(seconds / 60), int(seconds % 60))

heading += u"Сиды: {} Пиры: {}".format(info['num_seeds'], info['num_peers'])

self.info_label.setLabel(heading)

self.info_label_bg.setLabel(heading)

def __del__(self):

_debug('__del__')

self._hide_progress()

del self.info_label

del self.info_label_bg

def onPlayBackPaused(self):

self._show_progress()

self.is_playing = False

def onPlayBackResumed(self):

self._hide_progress()

self.is_playing = True

def onPlayBackEnded(self): self._hide_progress()

def onPlayBackStopped(self): self._hide_progress()

def onPlayBackError(self): self._hide_progress()

xbmc_player = OurPlayer()

_debug('OurPlayer creaded')

xbmcplugin.setResolvedUrl(handle, True, list_item)

_debug('setResolvedUrl')

while not xbmc_player.isPlaying():

xbmc.sleep(300)

_debug('!!!!!!!!!!!!!!!!! Start PLAYING !!!!!!!!!!!!!!!!!!!!!')

if k_db.timeOffset != 0:

_debug("Seek to time: " + str(k_db.timeOffset))

xbmc.sleep(2000)

xbmc_player.seekTime(int(k_db.timeOffset))

# Wait until playing finished or abort requested

while not xbmc.abortRequested and xbmc_player.isPlaying():

player.loop()

xbmc.sleep(1000)

xbmc_player.UpdateProgress()

_debug('!!!!!!!!!!!!!!!!! END PLAYING !!!!!!!!!!!!!!!!!!!!!')

xbmc.sleep(1000)

k_db.PlayerPostProccessing()

torrent_info = player.GetTorrentInfo()

torrent_path = player.path

info_hash = player.GetLastTorrentData()['info_hash']

xbmc.executebuiltin('Container.Refresh')

UpdateLibrary_path = filesystem.join(settings.base_path(), rel_path).encode('utf-8')

_debug(UpdateLibrary_path)

if not xbmc.getCondVisibility('Library.IsScanningVideo'):

from plugin import UpdateVideoLibrary

UpdateVideoLibrary(UpdateLibrary_path)

if settings.run_script \

or settings.remove_files \

or settings.move_video \

or settings.copy_torrent \

or settings.remeber_watched:

import afteractions

afteractions.Runner(settings, params, playable_item, torrent_info, torrent_path, info_hash)

except TPError as e:

_debug(e)

print_tb()

return play_torrent_variant.resultTryNext

except BaseException as e:

_debug(e)

print_tb()

finally:

_debug('player.close()')

player.close()

if xbmc_player:

del xbmc_player

tempPath = xbmc.translatePath('special://temp').decode('utf-8')

from downloader import TorrentDownloader

torr_downloader = TorrentDownloader(urllib.unquote(torrent_source), tempPath, settings)

path = filesystem.join(settings.torrents_path(), torr_downloader.get_subdir_name(),

torr_downloader.get_post_index() + '.torrent')

if not filesystem.exists(path):

if not torr_downloader.download():

return None

torr_downloader.move_file_to(path)

torr_downloader = None

try:

xbmcaddon.Addon(id='plugin.video.torrenter')

except:

return

if not nfoReader is None:

info = nfoReader.get_info()

ctitle = None

if 'title' in info:

ctitle = info['title']

elif 'originaltitle' in info:

ctitle = info['originaltitle']

if not ctitle is None:

uri = \

'%s?%s' % (

'plugin://plugin.video.torrenter/', urllib.urlencode({'action': 'search', 'url': ctitle.encode('utf-8')}))

debug('Search in torrenter: ' + uri)

from nforeader import NFOReader

info_dialog = xbmcgui.DialogProgress()

info_dialog.create(settings.addon_name)

tempPath = xbmc.translatePath('special://temp').decode('utf-8')

base_path = settings.base_path().encode('utf-8')

rel_path = urllib.unquote(params.get('path', ''))

nfoFilename = urllib.unquote(params.get('nfo', ''))

from base import get_true_filename

nfoFullPath = get_true_filename(NFOReader.make_path(base_path, rel_path, nfoFilename))

strmFilename = get_true_filename(nfoFullPath.replace('.nfo', '.strm'))

nfoReader = NFOReader(nfoFullPath, tempPath) if filesystem.exists(nfoFullPath) else None

debug(strmFilename)

from base import STRMWriterBase

links_with_ranks = STRMWriterBase.get_links_with_ranks(strmFilename, settings, use_scrape_info=True)

anidub_enable = _addon.getSetting('anidub_enable') == 'true'

hdclub_enable = False

bluebird_enable = _addon.getSetting('bluebird_enable') == 'true'

nnmclub_enable = _addon.getSetting('nnmclub_enable') == 'true'

rutor_enable = _addon.getSetting('rutor_enable') == 'true'

soap4me_enable = _addon.getSetting('soap4me_enable') == 'true'

kinohd_enable = _addon.getSetting('kinohd_enable') == 'true'

onlythis = False

if 'onlythis' in params and params['onlythis'] == 'true':

onlythis = True

for v in links_with_ranks[:]:

# if v['link'] in sys.argv[0] + sys.argv[2]:

# links_with_ranks.remove(v)

if not anidub_enable and 'tr.anidub.com' in v['link']:

links_with_ranks.remove(v)

if not hdclub_enable and 'hdclub.org' in v['link']:

links_with_ranks.remove(v)

if not bluebird_enable and 'bluebird.org' in v['link']:

links_with_ranks.remove(v)

if not nnmclub_enable and 'nnm-club.me' in v['link']:

links_with_ranks.remove(v)

if not rutor_enable and 'rutor.info' in v['link']:

links_with_ranks.remove(v)

if not soap4me_enable and 'soap4.me' in v['link']:

links_with_ranks.remove(v)

if not kinohd_enable and 'kinohd' in v['link']:

links_with_ranks.remove(v)

# debug('links_with_ranks: ' + str(links_with_ranks))

play_torrent_variant_result = None

if len(links_with_ranks) == 0 or onlythis:

torrent_source = params['torrent']

path_or_url_and_episode = get_path_or_url_and_episode(settings, params, torrent_source)

if path_or_url_and_episode:

path = path_or_url_and_episode['path_or_url']

episodeNumber = path_or_url_and_episode['episode']

downloader = path_or_url_and_episode['downloader']

play_torrent_variant_result = play_torrent_variant(path, info_dialog, episodeNumber, nfoReader, settings,

params, downloader)

if play_torrent_variant_result == play_torrent_variant.resultTryAgain:

play_torrent_variant_result = play_torrent_variant(path, info_dialog, episodeNumber, nfoReader,

settings, params, None)

else:

for tryCount, variant in enumerate(links_with_ranks, 1):

if tryCount > 1:

info_dialog.update(0, settings.addon_name, 'Попытка #%d' % tryCount)

# debug(variant)

torrent_source = variant['link']

try:

torrent_source = torrent_source.split('torrent=')[1].split('&')[0]

except:

continue

path_or_url_and_episode = get_path_or_url_and_episode(settings, params, torrent_source)

if path_or_url_and_episode is None:

continue

episodeNumber = path_or_url_and_episode['episode']

downloader = path_or_url_and_episode['downloader']

torr_params = params.copy()

try:

import urlparse

dct = urlparse.parse_qs(variant['link'])

torr_params['index'] = dct['index'][0]

torr_params.pop('cutName', None)

debug('Remove "cutName"')

except:

pass

play_torrent_variant_result = play_torrent_variant(path_or_url_and_episode['path_or_url'], info_dialog,

episodeNumber, nfoReader, settings, torr_params, downloader)

if play_torrent_variant_result == play_torrent_variant.resultTryAgain:

play_torrent_variant_result = play_torrent_variant(path_or_url_and_episode['path_or_url'], info_dialog,

episodeNumber, nfoReader, settings, torr_params, None)

if play_torrent_variant_result != play_torrent_variant.resultTryNext:

break

info_dialog.update(0, '', '')

debug('info_dialog.close')

info_dialog.close()

del info_dialog

try:

if play_torrent_variant_result == play_torrent_variant.resultTryNext and not onlythis:

# Open in torrenter

openInTorrenter(nfoReader)

except:

import sources

if sources.need_create(settings):

dialog = xbmcgui.Dialog()

if dialog.yesno(settings.addon_name, u'Источники категорий не созданы. Создать?'):

if sources.create(settings):

if dialog.yesno(settings.addon_name, restart_msg):

xbmc.executebuiltin('Quit')

return True

else:

return False

generate = 0

sources = 1

settings = 2

search = 3

catalog = 4

medialibrary = 5

if action == dialog_action_case.generate:

anidub_enable = _addon.getSetting('anidub_enable') == 'true'

hdclub_enable = False

bluebird_enable = _addon.getSetting('bluebird_enable') == 'true'

nnmclub_enable = _addon.getSetting('nnmclub_enable') == 'true'

rutor_enable = _addon.getSetting('rutor_enable') == 'true'

soap4me_enable = _addon.getSetting('soap4me_enable') == 'true'

kinohd_enable = _addon.getSetting('kinohd_enable') == 'true'

if not (anidub_enable or hdclub_enable or bluebird_enable or nnmclub_enable or rutor_enable or soap4me_enable or kinohd_enable):

xbmcgui.Dialog().ok(_ADDON_NAME, u'Пожалуйста, заполните настройки', u'Ни одного сайта не выбрано')

action = dialog_action_case.settings

else:

from service import start_generate

# if check_sources(settings):

start_generate()

return True

if action == dialog_action_case.sources:

import sources

dialog = xbmcgui.Dialog()

if sources.create(settings):

if dialog.yesno(settings.addon_name, restart_msg):

from service import update_library_next_start

update_library_next_start()

xbmc.executebuiltin('Quit')

if action == dialog_action_case.settings:

save_nnmclub_login = settings.nnmclub_login

save_nnmclub_password = settings.nnmclub_password

_addon.openSettings()

settings = load_settings()

"""

if save_nnmclub_login != settings.nnmclub_login or save_nnmclub_password != settings.nnmclub_password:

from nnmclub import get_passkey

passkey = get_passkey(settings=settings)

_addon.setSetting('nnmclub_passkey', passkey)

settings.nnmclub_passkey = passkey

"""

if action == dialog_action_case.search:

s = None

if not 'keyword' in params:

dlg = xbmcgui.Dialog()

s = dlg.input(u'Введите поисковую строку')

command = sys.argv[0] + sys.argv[2] + '&keyword=' + urllib.quote(s)

debug('Run command: {0}'.format(command))

xbmc.executebuiltin('Container.Update("{0}")'.format(command))

from plugin import kodi_ver

if kodi_ver()['major'] < 18:

debug('No keyword param. Return')

return False

else:

s = urllib.unquote(params.get('keyword'))

if s:

from movieapi import TMDB_API

debug('Keyword is: ' + s)

show_list(TMDB_API.search(s.decode('utf-8')))

if action == dialog_action_case.catalog:

addon_handle = int(sys.argv[1])

xbmcplugin.setContent(addon_handle, 'movies')

listing = [

('popular', u'Популярные'),

('top_rated', u'Рейтинговые'),

('popular_tv', u'Популярные сериалы'),

('top_rated_tv', u'Рейтинговые сериалы')

]

if filesystem.exists('special://home/addons/plugin.video.shikimori.2'):

listing.append(('anime', u'Аниме (Shikimori.org)' ), )

for l in listing:

li = xbmcgui.ListItem(l[1])

li.setProperty("folder", "true")

li.setProperty('IsPlayable', 'false')

url = 'plugin://script.media.aggregator/?action=show_category&category=' + l[0]

debug(url)

xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li, isFolder=True)

xbmcplugin.endOfDirectory(addon_handle)

if action == dialog_action_case.medialibrary:

addon_handle = int(sys.argv[1])

xbmcplugin.setContent(addon_handle, 'movies')

listing = [

('anime_top', u'Аниме: популярное'),

('anime_recomended', u'Аниме: текущее'),

('anime_last', u'Аниме: последнее'),

('animation_top', u'Мультфильмы: популярное'),

('animation_recomended', u'Мультфильмы: текущее'),

('animation_last', u'Мультфильмы: последнее'),

('animtv_top', u'Мультсериалы: популярное'),

('animtv_recomended', u'Мультсериалы: текущее'),

('animtv_last', u'Мультсериалы: последнее'),

('documentary_top', u'Документальные фильмы: популярное'),

('documentary_recomended', u'Документальные фильмы: текущее'),

('documentary_last', u'Документальные фильмы: последнее'),

('movie_top', u'Художественные фильмы: популярное'),

('movie_recomended', u'Художественные фильмы: текущее'),

('movie_last', u'Художественные фильмы: последнее'),

('tvshow_top', u'Сериалы: популярное'),

('tvshow_recomended', u'Сериалы: текущее'),

('tvshow_last', u'Сериалы: последнее'),

]

for l in listing:

li = xbmcgui.ListItem(l[1])

li.setProperty("folder", "true")

li.setProperty('IsPlayable', 'false')

url = 'plugin://script.media.aggregator/?action=show_library&category=' + l[0]

xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li, isFolder=True)

xbmcplugin.endOfDirectory(addon_handle)

if action > dialog_action_case.settings or action < dialog_action_case.generate:

return True

''' returns True if current listing is next page

else return False

'''

if not total_pages:

return False

from plugin import get_params

params = get_params()

if params:

page = int(params.get('page', 1))

if page < total_pages:

params['page'] = page + 1

url = make_url(params)

addon_handle = int(sys.argv[1])

li = xbmcgui.ListItem(u'[Далее]')

xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li, isFolder=True)

return page > 1

else:

addon_handle = int(sys.argv[1])

xbmcplugin.setContent(addon_handle, 'movies')

for item in listing:

info = item.get_info()

li = xbmcgui.ListItem(info['title'])

li.setInfo('video', info)

li.setArt(item.get_art())

url_search = make_url(

{'action': 'add_media',

'title': info['title'].encode('utf-8'),

'imdb': item.imdb()})

url_similar = make_url(

{'action': 'show_similar',

'type': item.type,

'tmdb': item.tmdb_id()})

items = [(u'Смотрите также', 'Container.Update("%s")' % url_similar),

(u'Искать источники', 'RunPlugin("%s")' % (url_search + '&force=true') )]

li.addContextMenuItems(items)

xbmcplugin.addDirectoryItem(handle=addon_handle, url=url_search, listitem=li)

updateListing = next_item(listing.total_pages)

u'Создать источники',

u'Настройки',

u'Поиск',

u'Каталог',

u'Медиатека'

'sources',

'settings',

'search',

'catalog',

'medialibrary'

indx = 0

addon_handle = int(sys.argv[1])

for menu in menu_items:

li = xbmcgui.ListItem(menu)

url = 'plugin://script.media.aggregator/?menu=' + menu_actions[indx]

xbmcplugin.addDirectoryItem(handle=addon_handle, url=url, listitem=li, isFolder=indx > dialog_action_case.settings)

indx += 1

title = urllib.unquote_plus(params.get('title')).decode('utf-8')

imdb = params.get('imdb')

force = params.get('force') == 'true'

if getSetting('role').decode('utf-8') == u'клиент' and params.get('norecursive'):

force_library_update(settings, params)

if force:

from service import add_media

add_media(title, imdb, settings)

return

found = None

from jsonrpc_requests import VideoLibrary

if imdb.startswith('sm') and title:

result = VideoLibrary.GetTVShows(properties=["title", "originaltitle", "year", "file", "imdbnumber"])

try:

for r in result['tvshows']:

if r['originaltitle'] == title:

found = 'tvshow'

break

except KeyError:

debug('KeyError: Animes not found')

if not found:

from complex_requests import get_movies_by_imdb

result = get_movies_by_imdb(imdb)

try:

if result:

if len(result['movies']) > 0:

r = result['movies'][0]

found = 'movie'

except KeyError:

debug('KeyError: Movies not found')

if not found:

result = VideoLibrary.GetTVShows(properties=["title", "originaltitle", "year", "file", "imdbnumber"])

try:

for r in result['tvshows']:

if r['imdbnumber'] == imdb:

found = 'tvshow'

break

except KeyError:

debug('KeyError: TVShows not found')

dialog = xbmcgui.Dialog()

if found == 'movie':

if dialog.yesno(u'Кино найдено в библиотеке', u'Запустить?'):

xbmc.executebuiltin('PlayMedia("%s")' % r['file'].encode('utf-8'))

elif found == 'tvshow':

if dialog.yesno(u'Сериал найден в библиотеке', u'Перейти?'):

xbmc.executebuiltin('ActivateWindow(Videos,%s,return)' % r['file'].encode('utf-8'))

elif not params.get('norecursive'):

if dialog.yesno(u'Кино/сериал не найден в библиотеке', u'Запустить поиск по трекерам?'):

from service import add_media

from movieapi import TMDB_API

page = params.get('page', 1)

listing = TMDB_API.show_similar_t(page, params.get('tmdb'), params.get('type'))

debug(listing)

page = params.get('page', 1)

#import vsdbg

#vsdbg._bp()

from movieapi import TMDB_API

if params.get('category') == 'popular':

show_list(TMDB_API.popular(page))

if params.get('category') == 'top_rated':

show_list(TMDB_API.top_rated(page))

if params.get('category') == 'popular_tv':

show_list(TMDB_API.popular_tv(page))

if params.get('category') == 'top_rated_tv':

show_list(TMDB_API.top_rated_tv(page))

if params.get('category') == 'anime':

uri = 'plugin://plugin.video.shikimori.2/'

addon_handle = int(sys.argv[1])