def test_clean_url(self):
"""
Test cleaning of urls
"""
log = logging.getLogger(__name__)
test = namedtuple('test', 'expected_result dirty clean')
url_tests = [
test(True, "https://subdomain.domain.tld/endpoint", "https://subdomain.domain.tld/endpoint"), # does not add a final /
test(True, "http://www.example.com/folder/", "http://www.example.com/folder/"), # does not remove the final /
test(True, "google.com/xml.rpc", "http://google.com/xml.rpc"), # add scheme if missing
test(True, "google.com", "http://google.com/"), # add scheme if missing and final / if its just the domain
test(True, "scgi:///home/user/.config/path/socket", "scgi:///home/user/.config/path/socket"), # scgi identified as scheme
test(True, None, ''), # None URL returns empty string
test(False, "https://subdomain.domain.tld/endpoint", "http://subdomain.domain.tld/endpoint"), # does not change schemes from https to http
test(False, "http://subdomain.domain.tld/endpoint", "https://subdomain.domain.tld/endpoint"), # ...or vice versa
test(False, "google.com/xml.rpc", "google.com/xml.rpc"), # scheme is always added
test(False, "google.com", "https://google.com/"), # does not default to https
test(False, "http://www.example.com/folder/", "http://www.example.com/folder"), # does not strip final /
test(False, "scgi:///home/user/.config/path/socket", "scgi:///home/user/.config/path/socket/"), # does not add a final /
test(AttributeError, 1, 1), # None URL returns empty string
]
for test_url in url_tests:
if issubclass(type(Exception), type(test_url.expected_result)):
with self.assertRaises(test_url.expected_result):
self.assertEqual(config.clean_url(test_url.dirty), test_url.clean)
elif test_url.expected_result is True:
self.assertEqual(config.clean_url(test_url.dirty), test_url.clean)
elif test_url.expected_result is False:
self.assertNotEqual(config.clean_url(test_url.dirty), test_url.clean)
else:
log.error('Test not defined for %s', test_url)
def test_clean_url(self):
"""
Test cleaning of urls
"""
log = logging.getLogger(__name__)
test = namedtuple('test', 'expected_result dirty clean')
url_tests = [
test(True, "https://subdomain.domain.tld/endpoint", "https://subdomain.domain.tld/endpoint"), # does not add a final /
test(True, "http://www.example.com/folder/", "http://www.example.com/folder/"), # does not remove the final /
test(True, "google.com/xml.rpc", "http://google.com/xml.rpc"), # add scheme if missing
test(True, "google.com", "http://google.com/"), # add scheme if missing and final / if its just the domain
test(True, "scgi:///home/user/.config/path/socket", "scgi:///home/user/.config/path/socket"), # scgi identified as scheme
test(True, None, ''), # None URL returns empty string
test(False, "https://subdomain.domain.tld/endpoint", "http://subdomain.domain.tld/endpoint"), # does not change schemes from https to http
test(False, "http://subdomain.domain.tld/endpoint", "https://subdomain.domain.tld/endpoint"), # ...or vice versa
test(False, "google.com/xml.rpc", "google.com/xml.rpc"), # scheme is always added
test(False, "google.com", "https://google.com/"), # does not default to https
test(False, "http://www.example.com/folder/", "http://www.example.com/folder"), # does not strip final /
test(False, "scgi:///home/user/.config/path/socket", "scgi:///home/user/.config/path/socket/"), # does not add a final /
test(AttributeError, 1, 1), # None URL returns empty string
]
for test_url in url_tests:
if issubclass(type(Exception), type(test_url.expected_result)):
with self.assertRaises(test_url.expected_result):
self.assertEqual(config.clean_url(test_url.dirty), test_url.clean)
elif test_url.expected_result is True:
self.assertEqual(config.clean_url(test_url.dirty), test_url.clean)
elif test_url.expected_result is False:
self.assertNotEqual(config.clean_url(test_url.dirty), test_url.clean)
else:
log.error('Test not defined for %s', test_url)
def test_clean_url(self):
self.assertEqual(config.clean_url("https://subdomain.domain.tld/endpoint"),
"https://subdomain.domain.tld/endpoint")
self.assertEqual(config.clean_url("google.com/xml.rpc"), "http://google.com/xml.rpc")
self.assertEqual(config.clean_url("google.com"), "http://google.com/")
self.assertEqual(config.clean_url("http://www.example.com/folder/"), "http://www.example.com/folder/")
self.assertEqual(config.clean_url("scgi:///home/user/.config/path/socket"),
"scgi:///home/user/.config/path/socket")
def test_clean_url(self):
self.assertEqual(
config.clean_url("https://subdomain.domain.tld/endpoint"), "https://subdomain.domain.tld/endpoint"
)
self.assertEqual(config.clean_url("google.com/xml.rpc"), "http://google.com/xml.rpc")
self.assertEqual(config.clean_url("google.com"), "http://google.com/")
self.assertEqual(config.clean_url("http://www.example.com/folder/"), "http://www.example.com/folder/")
self.assertEqual(
config.clean_url("scgi:///home/user/.config/path/socket"), "scgi:///home/user/.config/path/socket"
)
def saveNewznabProvider(name, url, key=''):
"""
Save a Newznab Provider
"""
if not name or not url:
return '0'
provider_dict = dict(zip([x.name for x in sickbeard.newznabProviderList], sickbeard.newznabProviderList))
if name in provider_dict:
if not provider_dict[name].default:
provider_dict[name].name = name
provider_dict[name].url = config.clean_url(url)
provider_dict[name].key = key
# a 0 in the key spot indicates that no key is needed
if key == '0':
provider_dict[name].needs_auth = False
else:
provider_dict[name].needs_auth = True
return '|'.join([provider_dict[name].get_id(), provider_dict[name].configStr()])
else:
new_provider = newznab.NewznabProvider(name, url, key=key)
sickbeard.newznabProviderList.append(new_provider)
return '|'.join([new_provider.get_id(), new_provider.configStr()])
def sendNZB(nzb):
if not sickbeard.NZBGET_HOST:
logger.log(
u"No NZBGet host found in configuration. Please configure it.",
logger.ERROR)
return False
nzb_filename = nzb.name + ".nzb"
try:
url = config.clean_url(sickbeard.NZBGET_HOST)
scheme, netloc, path, query, fragment = urlparse.urlsplit(
url) # @UnusedVariable
if sickbeard.NZBGET_USERNAME or sickbeard.NZBGET_PASSWORD:
netloc = urllib.quote_plus(
sickbeard.NZBGET_USERNAME.encode(
"utf-8", 'ignore')) + u":" + urllib.quote_plus(
sickbeard.NZBGET_PASSWORD.encode(
"utf-8", 'ignore')) + u"@" + netloc
url = urlparse.urlunsplit((scheme, netloc, u"/xmlrpc", "", ""))
logger.log(u"Sending NZB to NZBGet")
logger.log(u"NZBGet URL: " + url, logger.DEBUG)
nzbGetRPC = xmlrpclib.ServerProxy(url.encode("utf-8", 'ignore'))
if nzbGetRPC.writelog(
"INFO", "SickBeard connected to drop off " + nzb_filename +
" any moment now."):
logger.log(u"Successful connected to NZBGet", logger.DEBUG)
else:
logger.log(
u"Successful connected to NZBGet, but unable to send a message",
logger.ERROR)
except httplib.socket.error:
logger.log(
u"Please check if NZBGet is running. NZBGet is not responding.",
logger.ERROR)
return False
except xmlrpclib.ProtocolError, e:
if (e.errmsg == "Unauthorized"):
logger.log(u"NZBGet username or password is incorrect.",
logger.ERROR)
else:
logger.log(u"NZBGet protocol error: " + e.errmsg, logger.ERROR)
return False
def sendNZB(nzb):
addToTop = False
nzbgetprio = 0
if sickbeard.NZBGET_HOST == None:
logger.log(
u"No NZBGet host found in configuration. Please configure it.",
logger.ERROR)
return False
url = config.clean_url(sickbeard.NZBGET_HOST)
if sickbeard.NZBGET_USERNAME or sickbeard.NZBGET_PASSWORD:
scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
netloc = sickbeard.NZBGET_USERNAME + ":" + sickbeard.NZBGET_PASSWORD + "@" + netloc
url = urlparse.urlunsplit((scheme, netloc, path, query, fragment))
url = urlparse.urljoin(url, "/xmlrpc")
try:
nzbGetRPC = xmlrpclib.ServerProxy(url)
if nzbGetRPC.writelog(
"INFO", "SickBeard connected to drop off " + nzb.name +
".nzb" + " any moment now."):
logger.log(u"Successful connected to NZBGet", logger.DEBUG)
else:
logger.log(
u"Successful connected to NZBGet, but unable to send a message",
logger.ERROR)
except httplib.socket.error:
logger.log(
u"Please check if NZBGet is running. NZBGet is not responding.",
logger.ERROR)
return False
except xmlrpclib.ProtocolError, e:
if (e.errmsg == "Unauthorized"):
logger.log(u"NZBGet username or password is incorrect.",
logger.ERROR)
else:
logger.log(u"Protocol Error: " + e.errmsg, logger.ERROR)
return False
def canAddTorrentRssProvider(name, url, cookies, titleTAG):
if not name:
return json.dumps({'error': 'Invalid name specified'})
url = config.clean_url(url)
tempProvider = rsstorrent.TorrentRssProvider(name, url, cookies, titleTAG)
if tempProvider.get_id() in (x.get_id() for x in sickbeard.torrentRssProviderList):
return json.dumps({'error': 'Exists as ' + tempProvider.name})
else:
(succ, errMsg) = tempProvider.validateRSS()
if succ:
return json.dumps({'success': tempProvider.get_id()})
else:
return json.dumps({'error': errMsg})
def sendNZB(nzb):
if not sickbeard.NZBGET_HOST:
logger.log(u"No NZBGet host found in configuration. Please configure it.", logger.ERROR)
return False
nzb_filename = nzb.name + ".nzb"
try:
url = config.clean_url(sickbeard.NZBGET_HOST)
scheme, netloc, path, query, fragment = urlparse.urlsplit(url) # @UnusedVariable
if sickbeard.NZBGET_USERNAME or sickbeard.NZBGET_PASSWORD:
netloc = (
urllib.quote_plus(sickbeard.NZBGET_USERNAME.encode("utf-8", "ignore"))
+ u":"
+ urllib.quote_plus(sickbeard.NZBGET_PASSWORD.encode("utf-8", "ignore"))
+ u"@"
+ netloc
)
url = urlparse.urlunsplit((scheme, netloc, u"/xmlrpc", "", ""))
logger.log(u"Sending NZB to NZBGet")
logger.log(u"NZBGet URL: " + url, logger.DEBUG)
nzbGetRPC = xmlrpclib.ServerProxy(url.encode("utf-8", "ignore"))
if nzbGetRPC.writelog("INFO", "SickBeard connected to drop off " + nzb_filename + " any moment now."):
logger.log(u"Successful connected to NZBGet", logger.DEBUG)
else:
logger.log(u"Successful connected to NZBGet, but unable to send a message", logger.ERROR)
except httplib.socket.error:
logger.log(u"Please check if NZBGet is running. NZBGet is not responding.", logger.ERROR)
return False
except xmlrpclib.ProtocolError, e:
if e.errmsg == "Unauthorized":
logger.log(u"NZBGet username or password is incorrect.", logger.ERROR)
else:
logger.log(u"NZBGet protocol error: " + e.errmsg, logger.ERROR)
return False
def sendNZB(nzb):
addToTop = False
nzbgetprio = 0
if sickbeard.NZBGET_HOST == None:
logger.log(u"No NZBGet host found in configuration. Please configure it.", logger.ERROR)
return False
url = config.clean_url(sickbeard.NZBGET_HOST)
if sickbeard.NZBGET_USERNAME or sickbeard.NZBGET_PASSWORD:
scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
netloc = sickbeard.NZBGET_USERNAME + ":" + sickbeard.NZBGET_PASSWORD + "@" + netloc
url = urlparse.urlunsplit((scheme, netloc, path, query, fragment))
url = urlparse.urljoin(url, "/xmlrpc")
try:
nzbGetRPC = xmlrpclib.ServerProxy(url)
if nzbGetRPC.writelog("INFO", "SickBeard connected to drop off " + nzb.name + ".nzb" + " any moment now."):
logger.log(u"Successful connected to NZBGet", logger.DEBUG)
else:
logger.log(u"Successful connected to NZBGet, but unable to send a message", logger.ERROR)
except httplib.socket.error:
logger.log(u"Please check if NZBGet is running. NZBGet is not responding.", logger.ERROR)
return False
except xmlrpclib.ProtocolError, e:
if (e.errmsg == "Unauthorized"):
logger.log(u"NZBGet username or password is incorrect.", logger.ERROR)
else:
logger.log(u"Protocol Error: " + e.errmsg, logger.ERROR)
return False
def saveTorrentRssProvider(name, url, cookies, titleTAG):
"""
Save a Torrent Provider
"""
if not name or not url:
return '0'
provider_dict = dict(zip([x.name for x in sickbeard.torrentRssProviderList], sickbeard.torrentRssProviderList))
if name in provider_dict:
provider_dict[name].name = name
provider_dict[name].url = config.clean_url(url)
provider_dict[name].cookies = cookies
provider_dict[name].titleTAG = titleTAG
return '|'.join([provider_dict[name].get_id(), provider_dict[name].configStr()])
else:
new_provider = rsstorrent.TorrentRssProvider(name, url, cookies, titleTAG)
sickbeard.torrentRssProviderList.append(new_provider)
return '|'.join([new_provider.get_id(), new_provider.configStr()])
def saveSearch(self,
use_nzbs=None,
use_torrents=None,
nzb_dir=None,
sab_username=None,
sab_password=None,
sab_apikey=None,
sab_category=None,
sab_category_anime=None,
sab_category_backlog=None,
sab_category_anime_backlog=None,
sab_host=None,
nzbget_username=None,
nzbget_password=None,
nzbget_category=None,
nzbget_category_backlog=None,
nzbget_category_anime=None,
nzbget_category_anime_backlog=None,
nzbget_priority=None,
nzbget_host=None,
nzbget_use_https=None,
backlog_days=None,
backlog_frequency=None,
dailysearch_frequency=None,
nzb_method=None,
torrent_method=None,
usenet_retention=None,
download_propers=None,
check_propers_interval=None,
allow_high_priority=None,
sab_forced=None,
randomize_providers=None,
use_failed_downloads=None,
delete_failed=None,
backlog_missing_only=None,
torrent_dir=None,
torrent_username=None,
torrent_password=None,
torrent_host=None,
torrent_label=None,
torrent_label_anime=None,
torrent_path=None,
torrent_download_dir_deluge=None,
torrent_complete_dir_deluge=None,
torrent_verify_cert=None,
torrent_seed_time=None,
torrent_paused=None,
torrent_high_bandwidth=None,
torrent_rpcurl=None,
torrent_auth_type=None,
ignore_words=None,
trackers_list=None,
require_words=None,
ignored_subs_list=None,
syno_dsm_host=None,
syno_dsm_user=None,
syno_dsm_pass=None,
syno_dsm_path=None,
quality_allow_hevc=False,
prefer_words=None):
results = []
if not config.change_nzb_dir(nzb_dir):
results += [
"Unable to create directory " + ek(os.path.normpath, nzb_dir) +
", dir not changed."
]
if not config.change_torrent_dir(torrent_dir):
results += [
"Unable to create directory " +
ek(os.path.normpath, torrent_dir) + ", dir not changed."
]
config.change_daily_search_frequency(dailysearch_frequency)
config.change_backlog_frequency(backlog_frequency)
sickbeard.BACKLOG_DAYS = try_int(backlog_days, 7)
sickbeard.USE_NZBS = config.checkbox_to_value(use_nzbs)
sickbeard.USE_TORRENTS = config.checkbox_to_value(use_torrents)
sickbeard.NZB_METHOD = nzb_method
sickbeard.TORRENT_METHOD = torrent_method
sickbeard.USENET_RETENTION = try_int(usenet_retention, 500)
sickbeard.IGNORE_WORDS = ignore_words if ignore_words else ""
sickbeard.TRACKERS_LIST = trackers_list if trackers_list else ""
sickbeard.REQUIRE_WORDS = require_words if require_words else ""
sickbeard.PREFER_WORDS = prefer_words if prefer_words else ""
sickbeard.IGNORED_SUBS_LIST = ignored_subs_list if ignored_subs_list else ""
sickbeard.RANDOMIZE_PROVIDERS = config.checkbox_to_value(
randomize_providers)
config.change_download_propers(download_propers)
sickbeard.CHECK_PROPERS_INTERVAL = check_propers_interval
sickbeard.ALLOW_HIGH_PRIORITY = config.checkbox_to_value(
allow_high_priority)
sickbeard.QUALITY_ALLOW_HEVC = config.checkbox_to_value(
quality_allow_hevc)
sickbeard.USE_FAILED_DOWNLOADS = config.checkbox_to_value(
use_failed_downloads)
sickbeard.DELETE_FAILED = config.checkbox_to_value(delete_failed)
sickbeard.BACKLOG_MISSING_ONLY = config.checkbox_to_value(
backlog_missing_only)
sickbeard.SAB_USERNAME = sab_username
sickbeard.SAB_PASSWORD = filters.unhide(sickbeard.SAB_PASSWORD,
sab_password)
sickbeard.SAB_APIKEY = filters.unhide(sickbeard.SAB_APIKEY,
sab_apikey.strip())
sickbeard.SAB_CATEGORY = sab_category
sickbeard.SAB_CATEGORY_BACKLOG = sab_category_backlog
sickbeard.SAB_CATEGORY_ANIME = sab_category_anime
sickbeard.SAB_CATEGORY_ANIME_BACKLOG = sab_category_anime_backlog
sickbeard.SAB_HOST = config.clean_url(sab_host)
sickbeard.SAB_FORCED = config.checkbox_to_value(sab_forced)
sickbeard.NZBGET_USERNAME = nzbget_username
sickbeard.NZBGET_PASSWORD = filters.unhide(sickbeard.NZBGET_PASSWORD,
nzbget_password)
sickbeard.NZBGET_CATEGORY = nzbget_category
sickbeard.NZBGET_CATEGORY_BACKLOG = nzbget_category_backlog
sickbeard.NZBGET_CATEGORY_ANIME = nzbget_category_anime
sickbeard.NZBGET_CATEGORY_ANIME_BACKLOG = nzbget_category_anime_backlog
sickbeard.NZBGET_HOST = config.clean_host(nzbget_host)
sickbeard.NZBGET_USE_HTTPS = config.checkbox_to_value(nzbget_use_https)
sickbeard.NZBGET_PRIORITY = try_int(nzbget_priority, 100)
sickbeard.TORRENT_USERNAME = torrent_username
sickbeard.TORRENT_PASSWORD = filters.unhide(sickbeard.TORRENT_PASSWORD,
torrent_password)
sickbeard.TORRENT_LABEL = torrent_label
sickbeard.TORRENT_LABEL_ANIME = torrent_label_anime
sickbeard.TORRENT_VERIFY_CERT = config.checkbox_to_value(
torrent_verify_cert)
sickbeard.TORRENT_PATH = torrent_path.rstrip('/\\')
sickbeard.TORRENT_DELUGE_DOWNLOAD_DIR = torrent_download_dir_deluge.rstrip(
'/\\')
sickbeard.TORRENT_DELUGE_COMPLETE_DIR = torrent_complete_dir_deluge.rstrip(
'/\\')
sickbeard.TORRENT_SEED_TIME = torrent_seed_time
sickbeard.TORRENT_PAUSED = config.checkbox_to_value(torrent_paused)
sickbeard.TORRENT_HIGH_BANDWIDTH = config.checkbox_to_value(
torrent_high_bandwidth)
sickbeard.TORRENT_HOST = config.clean_url(torrent_host)
sickbeard.TORRENT_RPCURL = torrent_rpcurl
sickbeard.TORRENT_AUTH_TYPE = torrent_auth_type
sickbeard.SYNOLOGY_DSM_HOST = config.clean_url(syno_dsm_host)
sickbeard.SYNOLOGY_DSM_USERNAME = syno_dsm_user
sickbeard.SYNOLOGY_DSM_PASSWORD = filters.unhide(
sickbeard.SYNOLOGY_DSM_PASSWORD, syno_dsm_pass)
sickbeard.SYNOLOGY_DSM_PATH = syno_dsm_path.rstrip('/\\')
# This is a PITA, but lets merge the settings if they only set DSM up in one section to save them some time
if sickbeard.TORRENT_METHOD == 'download_station':
if not sickbeard.SYNOLOGY_DSM_HOST:
sickbeard.SYNOLOGY_DSM_HOST = sickbeard.TORRENT_HOST
if not sickbeard.SYNOLOGY_DSM_USERNAME:
sickbeard.SYNOLOGY_DSM_USERNAME = sickbeard.TORRENT_USERNAME
if not sickbeard.SYNOLOGY_DSM_PASSWORD:
sickbeard.SYNOLOGY_DSM_PASSWORD = sickbeard.TORRENT_PASSWORD
if not sickbeard.SYNOLOGY_DSM_PATH:
sickbeard.SYNOLOGY_DSM_PATH = sickbeard.TORRENT_PATH
if sickbeard.NZB_METHOD == 'download_station':
if not sickbeard.TORRENT_HOST:
sickbeard.TORRENT_HOST = sickbeard.SYNOLOGY_DSM_HOST
if not sickbeard.TORRENT_USERNAME:
sickbeard.TORRENT_USERNAME = sickbeard.SYNOLOGY_DSM_USERNAME
if not sickbeard.TORRENT_PASSWORD:
sickbeard.TORRENT_PASSWORD = sickbeard.SYNOLOGY_DSM_PASSWORD
if not sickbeard.TORRENT_PATH:
sickbeard.TORRENT_PATH = sickbeard.SYNOLOGY_DSM_PATH
helpers.manage_torrents_url(reset=True)
sickbeard.save_config()
if len(results) > 0:
for x in results:
logger.log(x, logger.ERROR)
ui.notifications.error(_('Error(s) Saving Configuration'),
'<br>\n'.join(results))
else:
ui.notifications.message(_('Configuration Saved'),
ek(os.path.join, sickbeard.CONFIG_FILE))
return self.redirect("/config/search/")
def saveNotifications(self,
use_kodi=None,
kodi_always_on=None,
kodi_notify_onsnatch=None,
kodi_notify_ondownload=None,
kodi_notify_onsubtitledownload=None,
kodi_update_onlyfirst=None,
kodi_update_library=None,
kodi_update_full=None,
kodi_host=None,
kodi_username=None,
kodi_password=None,
use_plex_server=None,
plex_notify_onsnatch=None,
plex_notify_ondownload=None,
plex_notify_onsubtitledownload=None,
plex_update_library=None,
plex_server_host=None,
plex_server_token=None,
plex_client_host=None,
plex_server_username=None,
plex_server_password=None,
use_plex_client=None,
plex_client_username=None,
plex_client_password=None,
plex_server_https=None,
use_emby=None,
emby_host=None,
emby_apikey=None,
use_growl=None,
growl_notify_onsnatch=None,
growl_notify_ondownload=None,
growl_notify_onsubtitledownload=None,
growl_host=None,
growl_password=None,
use_freemobile=None,
freemobile_notify_onsnatch=None,
freemobile_notify_ondownload=None,
freemobile_notify_onsubtitledownload=None,
freemobile_id=None,
freemobile_apikey=None,
use_telegram=None,
telegram_notify_onsnatch=None,
telegram_notify_ondownload=None,
telegram_notify_onsubtitledownload=None,
telegram_id=None,
telegram_apikey=None,
use_join=None,
join_notify_onsnatch=None,
join_notify_ondownload=None,
join_notify_onsubtitledownload=None,
join_id=None,
join_apikey=None,
use_prowl=None,
prowl_notify_onsnatch=None,
prowl_notify_ondownload=None,
prowl_notify_onsubtitledownload=None,
prowl_api=None,
prowl_priority=0,
prowl_show_list=None,
prowl_show=None,
prowl_message_title=None,
use_twitter=None,
twitter_notify_onsnatch=None,
twitter_notify_ondownload=None,
twitter_notify_onsubtitledownload=None,
twitter_usedm=None,
twitter_dmto=None,
use_twilio=None,
twilio_notify_onsnatch=None,
twilio_notify_ondownload=None,
twilio_notify_onsubtitledownload=None,
twilio_phone_sid=None,
twilio_account_sid=None,
twilio_auth_token=None,
twilio_to_number=None,
use_boxcar2=None,
boxcar2_notify_onsnatch=None,
boxcar2_notify_ondownload=None,
boxcar2_notify_onsubtitledownload=None,
boxcar2_accesstoken=None,
use_pushover=None,
pushover_notify_onsnatch=None,
pushover_notify_ondownload=None,
pushover_notify_onsubtitledownload=None,
pushover_userkey=None,
pushover_apikey=None,
pushover_device=None,
pushover_sound=None,
pushover_priority=0,
use_libnotify=None,
libnotify_notify_onsnatch=None,
libnotify_notify_ondownload=None,
libnotify_notify_onsubtitledownload=None,
use_nmj=None,
nmj_host=None,
nmj_database=None,
nmj_mount=None,
use_synoindex=None,
use_nmjv2=None,
nmjv2_host=None,
nmjv2_dbloc=None,
nmjv2_database=None,
use_trakt=None,
trakt_username=None,
trakt_pin=None,
trakt_remove_watchlist=None,
trakt_sync_watchlist=None,
trakt_remove_show_from_sickchill=None,
trakt_method_add=None,
trakt_start_paused=None,
trakt_use_recommended=None,
trakt_sync=None,
trakt_sync_remove=None,
trakt_default_indexer=None,
trakt_remove_serieslist=None,
trakt_timeout=None,
trakt_blacklist_name=None,
use_synologynotifier=None,
synologynotifier_notify_onsnatch=None,
synologynotifier_notify_ondownload=None,
synologynotifier_notify_onsubtitledownload=None,
use_pytivo=None,
pytivo_notify_onsnatch=None,
pytivo_notify_ondownload=None,
pytivo_notify_onsubtitledownload=None,
pytivo_update_library=None,
pytivo_host=None,
pytivo_share_name=None,
pytivo_tivo_name=None,
use_pushalot=None,
pushalot_notify_onsnatch=None,
pushalot_notify_ondownload=None,
pushalot_notify_onsubtitledownload=None,
pushalot_authorizationtoken=None,
use_pushbullet=None,
pushbullet_notify_onsnatch=None,
pushbullet_notify_ondownload=None,
pushbullet_notify_onsubtitledownload=None,
pushbullet_api=None,
pushbullet_device=None,
pushbullet_device_list=None,
pushbullet_channel_list=None,
pushbullet_channel=None,
use_email=None,
email_notify_onsnatch=None,
email_notify_ondownload=None,
email_notify_onpostprocess=None,
email_notify_onsubtitledownload=None,
email_host=None,
email_port=25,
email_from=None,
email_tls=None,
email_user=None,
email_password=None,
email_list=None,
email_subject=None,
email_show_list=None,
email_show=None,
use_slack=False,
slack_notify_snatch=None,
slack_notify_download=None,
slack_notify_subtitledownload=None,
slack_webhook=None,
slack_icon_emoji=None,
use_matrix=False,
matrix_notify_snatch=None,
matrix_notify_download=None,
matrix_notify_subtitledownload=None,
matrix_api_token=None,
matrix_server=None,
matrix_room=None,
use_discord=False,
discord_notify_snatch=None,
discord_notify_download=None,
discord_webhook=None,
discord_name=None,
discord_avatar_url=None,
discord_tts=False):
results = []
sickbeard.USE_KODI = config.checkbox_to_value(use_kodi)
sickbeard.KODI_ALWAYS_ON = config.checkbox_to_value(kodi_always_on)
sickbeard.KODI_NOTIFY_ONSNATCH = config.checkbox_to_value(
kodi_notify_onsnatch)
sickbeard.KODI_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
kodi_notify_ondownload)
sickbeard.KODI_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
kodi_notify_onsubtitledownload)
sickbeard.KODI_UPDATE_LIBRARY = config.checkbox_to_value(
kodi_update_library)
sickbeard.KODI_UPDATE_FULL = config.checkbox_to_value(kodi_update_full)
sickbeard.KODI_UPDATE_ONLYFIRST = config.checkbox_to_value(
kodi_update_onlyfirst)
sickbeard.KODI_HOST = config.clean_hosts(kodi_host)
sickbeard.KODI_USERNAME = kodi_username
sickbeard.KODI_PASSWORD = filters.unhide(sickbeard.KODI_PASSWORD,
kodi_password)
sickbeard.USE_PLEX_SERVER = config.checkbox_to_value(use_plex_server)
sickbeard.PLEX_NOTIFY_ONSNATCH = config.checkbox_to_value(
plex_notify_onsnatch)
sickbeard.PLEX_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
plex_notify_ondownload)
sickbeard.PLEX_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
plex_notify_onsubtitledownload)
sickbeard.PLEX_UPDATE_LIBRARY = config.checkbox_to_value(
plex_update_library)
sickbeard.PLEX_CLIENT_HOST = config.clean_hosts(plex_client_host)
sickbeard.PLEX_SERVER_HOST = config.clean_hosts(plex_server_host)
sickbeard.PLEX_SERVER_TOKEN = config.clean_host(plex_server_token)
sickbeard.PLEX_SERVER_USERNAME = plex_server_username
sickbeard.PLEX_SERVER_PASSWORD = filters.unhide(
sickbeard.PLEX_SERVER_PASSWORD, plex_server_password)
sickbeard.USE_PLEX_CLIENT = config.checkbox_to_value(use_plex_client)
sickbeard.PLEX_CLIENT_USERNAME = plex_client_username
sickbeard.PLEX_CLIENT_PASSWORD = filters.unhide(
sickbeard.PLEX_CLIENT_PASSWORD, plex_client_password)
sickbeard.PLEX_SERVER_HTTPS = config.checkbox_to_value(
plex_server_https)
sickbeard.USE_EMBY = config.checkbox_to_value(use_emby)
sickbeard.EMBY_HOST = config.clean_url(emby_host)
sickbeard.EMBY_APIKEY = filters.unhide(sickbeard.EMBY_APIKEY,
emby_apikey)
sickbeard.USE_GROWL = config.checkbox_to_value(use_growl)
sickbeard.GROWL_NOTIFY_ONSNATCH = config.checkbox_to_value(
growl_notify_onsnatch)
sickbeard.GROWL_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
growl_notify_ondownload)
sickbeard.GROWL_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
growl_notify_onsubtitledownload)
sickbeard.GROWL_HOST = config.clean_host(growl_host,
default_port=23053)
sickbeard.GROWL_PASSWORD = filters.unhide(sickbeard.GROWL_PASSWORD,
growl_password)
sickbeard.USE_FREEMOBILE = config.checkbox_to_value(use_freemobile)
sickbeard.FREEMOBILE_NOTIFY_ONSNATCH = config.checkbox_to_value(
freemobile_notify_onsnatch)
sickbeard.FREEMOBILE_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
freemobile_notify_ondownload)
sickbeard.FREEMOBILE_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
freemobile_notify_onsubtitledownload)
sickbeard.FREEMOBILE_ID = freemobile_id
sickbeard.FREEMOBILE_APIKEY = filters.unhide(
sickbeard.FREEMOBILE_APIKEY, freemobile_apikey)
sickbeard.USE_TELEGRAM = config.checkbox_to_value(use_telegram)
sickbeard.TELEGRAM_NOTIFY_ONSNATCH = config.checkbox_to_value(
telegram_notify_onsnatch)
sickbeard.TELEGRAM_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
telegram_notify_ondownload)
sickbeard.TELEGRAM_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
telegram_notify_onsubtitledownload)
sickbeard.TELEGRAM_ID = telegram_id
sickbeard.TELEGRAM_APIKEY = filters.unhide(sickbeard.TELEGRAM_APIKEY,
telegram_apikey)
sickbeard.USE_JOIN = config.checkbox_to_value(use_join)
sickbeard.JOIN_NOTIFY_ONSNATCH = config.checkbox_to_value(
join_notify_onsnatch)
sickbeard.JOIN_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
join_notify_ondownload)
sickbeard.JOIN_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
join_notify_onsubtitledownload)
sickbeard.JOIN_ID = join_id
sickbeard.JOIN_APIKEY = filters.unhide(sickbeard.JOIN_APIKEY,
join_apikey)
sickbeard.USE_PROWL = config.checkbox_to_value(use_prowl)
sickbeard.PROWL_NOTIFY_ONSNATCH = config.checkbox_to_value(
prowl_notify_onsnatch)
sickbeard.PROWL_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
prowl_notify_ondownload)
sickbeard.PROWL_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
prowl_notify_onsubtitledownload)
sickbeard.PROWL_API = prowl_api
sickbeard.PROWL_PRIORITY = prowl_priority
sickbeard.PROWL_MESSAGE_TITLE = prowl_message_title
sickbeard.USE_TWITTER = config.checkbox_to_value(use_twitter)
sickbeard.TWITTER_NOTIFY_ONSNATCH = config.checkbox_to_value(
twitter_notify_onsnatch)
sickbeard.TWITTER_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
twitter_notify_ondownload)
sickbeard.TWITTER_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
twitter_notify_onsubtitledownload)
sickbeard.TWITTER_USEDM = config.checkbox_to_value(twitter_usedm)
sickbeard.TWITTER_DMTO = twitter_dmto
sickbeard.USE_TWILIO = config.checkbox_to_value(use_twilio)
sickbeard.TWILIO_NOTIFY_ONSNATCH = config.checkbox_to_value(
twilio_notify_onsnatch)
sickbeard.TWILIO_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
twilio_notify_ondownload)
sickbeard.TWILIO_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
twilio_notify_onsubtitledownload)
sickbeard.TWILIO_PHONE_SID = twilio_phone_sid
sickbeard.TWILIO_ACCOUNT_SID = twilio_account_sid
sickbeard.TWILIO_AUTH_TOKEN = twilio_auth_token
sickbeard.TWILIO_TO_NUMBER = twilio_to_number
sickbeard.USE_SLACK = config.checkbox_to_value(use_slack)
sickbeard.SLACK_NOTIFY_SNATCH = config.checkbox_to_value(
slack_notify_snatch)
sickbeard.SLACK_NOTIFY_DOWNLOAD = config.checkbox_to_value(
slack_notify_download)
sickbeard.SLACK_NOTIFY_SUBTITLEDOWNLOAD = config.checkbox_to_value(
slack_notify_subtitledownload)
sickbeard.SLACK_WEBHOOK = slack_webhook
sickbeard.SLACK_ICON_EMOJI = slack_icon_emoji
sickbeard.USE_MATRIX = config.checkbox_to_value(use_matrix)
sickbeard.MATRIX_NOTIFY_SNATCH = config.checkbox_to_value(
matrix_notify_snatch)
sickbeard.MATRIX_NOTIFY_DOWNLOAD = config.checkbox_to_value(
matrix_notify_download)
sickbeard.MATRIX_NOTIFY_SUBTITLEDOWNLOAD = config.checkbox_to_value(
matrix_notify_subtitledownload)
sickbeard.MATRIX_API_TOKEN = matrix_api_token
sickbeard.MATRIX_SERVER = matrix_server
sickbeard.MATRIX_ROOM = matrix_room
sickbeard.USE_DISCORD = config.checkbox_to_value(use_discord)
sickbeard.DISCORD_NOTIFY_SNATCH = config.checkbox_to_value(
discord_notify_snatch)
sickbeard.DISCORD_NOTIFY_DOWNLOAD = config.checkbox_to_value(
discord_notify_download)
sickbeard.DISCORD_WEBHOOK = discord_webhook
sickbeard.DISCORD_NAME = discord_name
sickbeard.DISCORD_AVATAR_URL = discord_avatar_url
sickbeard.DISCORD_TTS = discord_tts
sickbeard.USE_BOXCAR2 = config.checkbox_to_value(use_boxcar2)
sickbeard.BOXCAR2_NOTIFY_ONSNATCH = config.checkbox_to_value(
boxcar2_notify_onsnatch)
sickbeard.BOXCAR2_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
boxcar2_notify_ondownload)
sickbeard.BOXCAR2_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
boxcar2_notify_onsubtitledownload)
sickbeard.BOXCAR2_ACCESSTOKEN = boxcar2_accesstoken
sickbeard.USE_PUSHOVER = config.checkbox_to_value(use_pushover)
sickbeard.PUSHOVER_NOTIFY_ONSNATCH = config.checkbox_to_value(
pushover_notify_onsnatch)
sickbeard.PUSHOVER_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
pushover_notify_ondownload)
sickbeard.PUSHOVER_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
pushover_notify_onsubtitledownload)
sickbeard.PUSHOVER_USERKEY = pushover_userkey
sickbeard.PUSHOVER_APIKEY = filters.unhide(sickbeard.PUSHOVER_APIKEY,
pushover_apikey)
sickbeard.PUSHOVER_DEVICE = pushover_device
sickbeard.PUSHOVER_SOUND = pushover_sound
sickbeard.PUSHOVER_PRIORITY = pushover_priority
sickbeard.USE_LIBNOTIFY = config.checkbox_to_value(use_libnotify)
sickbeard.LIBNOTIFY_NOTIFY_ONSNATCH = config.checkbox_to_value(
libnotify_notify_onsnatch)
sickbeard.LIBNOTIFY_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
libnotify_notify_ondownload)
sickbeard.LIBNOTIFY_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
libnotify_notify_onsubtitledownload)
sickbeard.USE_NMJ = config.checkbox_to_value(use_nmj)
sickbeard.NMJ_HOST = config.clean_host(nmj_host)
sickbeard.NMJ_DATABASE = nmj_database
sickbeard.NMJ_MOUNT = nmj_mount
sickbeard.USE_NMJv2 = config.checkbox_to_value(use_nmjv2)
sickbeard.NMJv2_HOST = config.clean_host(nmjv2_host)
sickbeard.NMJv2_DATABASE = nmjv2_database
sickbeard.NMJv2_DBLOC = nmjv2_dbloc
sickbeard.USE_SYNOINDEX = config.checkbox_to_value(use_synoindex)
sickbeard.USE_SYNOLOGYNOTIFIER = config.checkbox_to_value(
use_synologynotifier)
sickbeard.SYNOLOGYNOTIFIER_NOTIFY_ONSNATCH = config.checkbox_to_value(
synologynotifier_notify_onsnatch)
sickbeard.SYNOLOGYNOTIFIER_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
synologynotifier_notify_ondownload)
sickbeard.SYNOLOGYNOTIFIER_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
synologynotifier_notify_onsubtitledownload)
config.change_use_trakt(use_trakt)
sickbeard.TRAKT_USERNAME = trakt_username
sickbeard.TRAKT_REMOVE_WATCHLIST = config.checkbox_to_value(
trakt_remove_watchlist)
sickbeard.TRAKT_REMOVE_SERIESLIST = config.checkbox_to_value(
trakt_remove_serieslist)
sickbeard.TRAKT_REMOVE_SHOW_FROM_SICKCHILL = config.checkbox_to_value(
trakt_remove_show_from_sickchill)
sickbeard.TRAKT_SYNC_WATCHLIST = config.checkbox_to_value(
trakt_sync_watchlist)
sickbeard.TRAKT_METHOD_ADD = int(trakt_method_add)
sickbeard.TRAKT_START_PAUSED = config.checkbox_to_value(
trakt_start_paused)
sickbeard.TRAKT_USE_RECOMMENDED = config.checkbox_to_value(
trakt_use_recommended)
sickbeard.TRAKT_SYNC = config.checkbox_to_value(trakt_sync)
sickbeard.TRAKT_SYNC_REMOVE = config.checkbox_to_value(
trakt_sync_remove)
sickbeard.TRAKT_DEFAULT_INDEXER = int(trakt_default_indexer)
sickbeard.TRAKT_TIMEOUT = int(trakt_timeout)
sickbeard.TRAKT_BLACKLIST_NAME = trakt_blacklist_name
sickbeard.USE_EMAIL = config.checkbox_to_value(use_email)
sickbeard.EMAIL_NOTIFY_ONSNATCH = config.checkbox_to_value(
email_notify_onsnatch)
sickbeard.EMAIL_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
email_notify_ondownload)
sickbeard.EMAIL_NOTIFY_ONPOSTPROCESS = config.checkbox_to_value(
email_notify_onpostprocess)
sickbeard.EMAIL_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
email_notify_onsubtitledownload)
sickbeard.EMAIL_HOST = config.clean_host(email_host)
sickbeard.EMAIL_PORT = try_int(email_port, 25)
sickbeard.EMAIL_FROM = email_from
sickbeard.EMAIL_TLS = config.checkbox_to_value(email_tls)
sickbeard.EMAIL_USER = email_user
sickbeard.EMAIL_PASSWORD = filters.unhide(sickbeard.EMAIL_PASSWORD,
email_password)
sickbeard.EMAIL_LIST = email_list
sickbeard.EMAIL_SUBJECT = email_subject
sickbeard.USE_PYTIVO = config.checkbox_to_value(use_pytivo)
sickbeard.PYTIVO_NOTIFY_ONSNATCH = config.checkbox_to_value(
pytivo_notify_onsnatch)
sickbeard.PYTIVO_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
pytivo_notify_ondownload)
sickbeard.PYTIVO_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
pytivo_notify_onsubtitledownload)
sickbeard.PYTIVO_UPDATE_LIBRARY = config.checkbox_to_value(
pytivo_update_library)
sickbeard.PYTIVO_HOST = config.clean_host(pytivo_host)
sickbeard.PYTIVO_SHARE_NAME = pytivo_share_name
sickbeard.PYTIVO_TIVO_NAME = pytivo_tivo_name
sickbeard.USE_PUSHALOT = config.checkbox_to_value(use_pushalot)
sickbeard.PUSHALOT_NOTIFY_ONSNATCH = config.checkbox_to_value(
pushalot_notify_onsnatch)
sickbeard.PUSHALOT_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
pushalot_notify_ondownload)
sickbeard.PUSHALOT_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
pushalot_notify_onsubtitledownload)
sickbeard.PUSHALOT_AUTHORIZATIONTOKEN = pushalot_authorizationtoken
sickbeard.USE_PUSHBULLET = config.checkbox_to_value(use_pushbullet)
sickbeard.PUSHBULLET_NOTIFY_ONSNATCH = config.checkbox_to_value(
pushbullet_notify_onsnatch)
sickbeard.PUSHBULLET_NOTIFY_ONDOWNLOAD = config.checkbox_to_value(
pushbullet_notify_ondownload)
sickbeard.PUSHBULLET_NOTIFY_ONSUBTITLEDOWNLOAD = config.checkbox_to_value(
pushbullet_notify_onsubtitledownload)
sickbeard.PUSHBULLET_API = pushbullet_api
sickbeard.PUSHBULLET_DEVICE = pushbullet_device_list
sickbeard.PUSHBULLET_CHANNEL = pushbullet_channel_list or ""
sickbeard.save_config()
if len(results) > 0:
for x in results:
logger.log(x, logger.ERROR)
ui.notifications.error(_('Error(s) Saving Configuration'),
'<br>\n'.join(results))
else:
ui.notifications.message(_('Configuration Saved'),
ek(os.path.join, sickbeard.CONFIG_FILE))
return self.redirect("/config/notifications/")
def saveProviders(self, newznab_string='', torrentrss_string='', provider_order=None, **kwargs):
"""
Save Provider related settings
"""
results = []
provider_str_list = provider_order.split()
provider_list = []
newznab_provider_dict = dict(
zip([x.get_id() for x in sickbeard.newznabProviderList], sickbeard.newznabProviderList))
finished_names = []
# add all the newznab info we got into our list
if newznab_string:
for curNewznabProviderStr in newznab_string.split('!!!'):
if not curNewznabProviderStr:
continue
cur_name, cur_url, cur_key, cur_cat = curNewznabProviderStr.split('|')
cur_url = config.clean_url(cur_url)
new_provider = newznab.NewznabProvider(cur_name, cur_url, key=cur_key, catIDs=cur_cat)
cur_id = new_provider.get_id()
# if it already exists then update it
if cur_id in newznab_provider_dict:
newznab_provider_dict[cur_id].name = cur_name
newznab_provider_dict[cur_id].url = cur_url
newznab_provider_dict[cur_id].key = cur_key
newznab_provider_dict[cur_id].catIDs = cur_cat
# a 0 in the key spot indicates that no key is needed
if cur_key == '0':
newznab_provider_dict[cur_id].needs_auth = False
else:
newznab_provider_dict[cur_id].needs_auth = True
try:
newznab_provider_dict[cur_id].search_mode = str(kwargs['{id}_search_mode'.format(id=cur_id)]).strip()
except (AttributeError, KeyError):
pass # these exceptions are actually catching unselected checkboxes
try:
newznab_provider_dict[cur_id].search_fallback = config.checkbox_to_value(
kwargs['{id}_search_fallback'.format(id=cur_id)])
except (AttributeError, KeyError):
newznab_provider_dict[cur_id].search_fallback = 0 # these exceptions are actually catching unselected checkboxes
try:
newznab_provider_dict[cur_id].enable_daily = config.checkbox_to_value(
kwargs['{id}_enable_daily'.format(id=cur_id)])
except (AttributeError, KeyError):
newznab_provider_dict[cur_id].enable_daily = 0 # these exceptions are actually catching unselected checkboxes
try:
newznab_provider_dict[cur_id].enable_manualsearch = config.checkbox_to_value(
kwargs['{id}_enable_manualsearch'.format(id=cur_id)])
except (AttributeError, KeyError):
newznab_provider_dict[cur_id].enable_manualsearch = 0 # these exceptions are actually catching unselected checkboxes
try:
newznab_provider_dict[cur_id].enable_backlog = config.checkbox_to_value(
kwargs['{id}_enable_backlog'.format(id=cur_id)])
except (AttributeError, KeyError):
newznab_provider_dict[cur_id].enable_backlog = 0 # these exceptions are actually catching unselected checkboxes
else:
sickbeard.newznabProviderList.append(new_provider)
finished_names.append(cur_id)
# delete anything that is missing
for cur_provider in sickbeard.newznabProviderList:
if cur_provider.get_id() not in finished_names:
sickbeard.newznabProviderList.remove(cur_provider)
torrent_rss_provider_dict = dict(
zip([x.get_id() for x in sickbeard.torrentRssProviderList], sickbeard.torrentRssProviderList))
finished_names = []
if torrentrss_string:
for curTorrentRssProviderStr in torrentrss_string.split('!!!'):
if not curTorrentRssProviderStr:
continue
cur_name, cur_url, cur_cookies, cur_title_tag = curTorrentRssProviderStr.split('|')
cur_url = config.clean_url(cur_url)
new_provider = rsstorrent.TorrentRssProvider(cur_name, cur_url, cur_cookies, cur_title_tag)
cur_id = new_provider.get_id()
# if it already exists then update it
if cur_id in torrent_rss_provider_dict:
torrent_rss_provider_dict[cur_id].name = cur_name
torrent_rss_provider_dict[cur_id].url = cur_url
torrent_rss_provider_dict[cur_id].cookies = cur_cookies
torrent_rss_provider_dict[cur_id].curTitleTAG = cur_title_tag
else:
sickbeard.torrentRssProviderList.append(new_provider)
finished_names.append(cur_id)
# delete anything that is missing
for cur_provider in sickbeard.torrentRssProviderList:
if cur_provider.get_id() not in finished_names:
sickbeard.torrentRssProviderList.remove(cur_provider)
disabled_list = []
# do the enable/disable
for cur_providerStr in provider_str_list:
cur_provider, cur_enabled = cur_providerStr.split(':')
cur_enabled = try_int(cur_enabled)
cur_prov_obj = [x for x in sickbeard.providers.sortedProviderList() if
x.get_id() == cur_provider and hasattr(x, 'enabled')]
if cur_prov_obj:
cur_prov_obj[0].enabled = bool(cur_enabled)
if cur_enabled:
provider_list.append(cur_provider)
else:
disabled_list.append(cur_provider)
if cur_provider in newznab_provider_dict:
newznab_provider_dict[cur_provider].enabled = bool(cur_enabled)
elif cur_provider in torrent_rss_provider_dict:
torrent_rss_provider_dict[cur_provider].enabled = bool(cur_enabled)
provider_list.extend(disabled_list)
# dynamically load provider settings
for curTorrentProvider in [prov for prov in sickbeard.providers.sortedProviderList() if
prov.provider_type == GenericProvider.TORRENT]:
if hasattr(curTorrentProvider, 'custom_url'):
try:
curTorrentProvider.custom_url = str(kwargs['{id}_custom_url'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.custom_url = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'minseed'):
try:
curTorrentProvider.minseed = int(str(kwargs['{id}_minseed'.format(id=curTorrentProvider.get_id())]).strip())
except (AttributeError, KeyError):
curTorrentProvider.minseed = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'minleech'):
try:
curTorrentProvider.minleech = int(str(kwargs['{id}_minleech'.format(id=curTorrentProvider.get_id())]).strip())
except (AttributeError, KeyError):
curTorrentProvider.minleech = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'ratio'):
try:
ratio = float(str(kwargs['{id}_ratio'.format(id=curTorrentProvider.get_id())]).strip())
curTorrentProvider.ratio = (ratio, -1)[ratio < 0]
except (AttributeError, KeyError, ValueError):
curTorrentProvider.ratio = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'digest'):
try:
curTorrentProvider.digest = str(kwargs['{id}_digest'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.digest = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'hash'):
try:
curTorrentProvider.hash = str(kwargs['{id}_hash'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.hash = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'api_key'):
try:
curTorrentProvider.api_key = str(kwargs['{id}_api_key'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.api_key = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'username'):
try:
curTorrentProvider.username = str(kwargs['{id}_username'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.username = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'password'):
try:
curTorrentProvider.password = str(kwargs['{id}_password'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.password = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'passkey'):
try:
curTorrentProvider.passkey = str(kwargs['{id}_passkey'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.passkey = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'pin'):
try:
curTorrentProvider.pin = str(kwargs['{id}_pin'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.pin = None # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'confirmed'):
try:
curTorrentProvider.confirmed = config.checkbox_to_value(
kwargs['{id}_confirmed'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.confirmed = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'ranked'):
try:
curTorrentProvider.ranked = config.checkbox_to_value(
kwargs['{id}_ranked'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.ranked = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'engrelease'):
try:
curTorrentProvider.engrelease = config.checkbox_to_value(
kwargs['{id}_engrelease'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.engrelease = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'onlyspasearch'):
try:
curTorrentProvider.onlyspasearch = config.checkbox_to_value(
kwargs['{id}_onlyspasearch'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.onlyspasearch = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'sorting'):
try:
curTorrentProvider.sorting = str(kwargs['{id}_sorting'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.sorting = 'seeders' # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'freeleech'):
try:
curTorrentProvider.freeleech = config.checkbox_to_value(
kwargs['{id}_freeleech'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.freeleech = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'search_mode'):
try:
curTorrentProvider.search_mode = str(kwargs['{id}_search_mode'.format(id=curTorrentProvider.get_id())]).strip()
except (AttributeError, KeyError):
curTorrentProvider.search_mode = 'eponly' # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'search_fallback'):
try:
curTorrentProvider.search_fallback = config.checkbox_to_value(
kwargs['{id}_search_fallback'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.search_fallback = 0 # these exceptions are catching unselected checkboxes
if hasattr(curTorrentProvider, 'enable_daily'):
try:
curTorrentProvider.enable_daily = config.checkbox_to_value(
kwargs['{id}_enable_daily'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.enable_daily = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'enable_manualsearch'):
try:
curTorrentProvider.enable_manualsearch = config.checkbox_to_value(
kwargs['{id}_enable_manualsearch'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.enable_manualsearch = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'enable_backlog'):
try:
curTorrentProvider.enable_backlog = config.checkbox_to_value(
kwargs['{id}_enable_backlog'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.enable_backlog = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'cat'):
try:
curTorrentProvider.cat = int(str(kwargs['{id}_cat'.format(id=curTorrentProvider.get_id())]).strip())
except (AttributeError, KeyError):
curTorrentProvider.cat = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curTorrentProvider, 'subtitle'):
try:
curTorrentProvider.subtitle = config.checkbox_to_value(
kwargs['{id}_subtitle'.format(id=curTorrentProvider.get_id())])
except (AttributeError, KeyError):
curTorrentProvider.subtitle = 0 # these exceptions are actually catching unselected checkboxes
for curNzbProvider in [prov for prov in sickbeard.providers.sortedProviderList() if
prov.provider_type == GenericProvider.NZB]:
if hasattr(curNzbProvider, 'api_key'):
try:
curNzbProvider.api_key = str(kwargs['{id}_api_key'.format(id=curNzbProvider.get_id())]).strip()
except (AttributeError, KeyError):
curNzbProvider.api_key = None # these exceptions are actually catching unselected checkboxes
if hasattr(curNzbProvider, 'username'):
try:
curNzbProvider.username = str(kwargs['{id}_username'.format(id=curNzbProvider.get_id())]).strip()
except (AttributeError, KeyError):
curNzbProvider.username = None # these exceptions are actually catching unselected checkboxes
if hasattr(curNzbProvider, 'search_mode'):
try:
curNzbProvider.search_mode = str(kwargs['{id}_search_mode'.format(id=curNzbProvider.get_id())]).strip()
except (AttributeError, KeyError):
curNzbProvider.search_mode = 'eponly' # these exceptions are actually catching unselected checkboxes
if hasattr(curNzbProvider, 'search_fallback'):
try:
curNzbProvider.search_fallback = config.checkbox_to_value(
kwargs['{id}_search_fallback'.format(id=curNzbProvider.get_id())])
except (AttributeError, KeyError):
curNzbProvider.search_fallback = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curNzbProvider, 'enable_daily'):
try:
curNzbProvider.enable_daily = config.checkbox_to_value(
kwargs['{id}_enable_daily'.format(id=curNzbProvider.get_id())])
except (AttributeError, KeyError):
curNzbProvider.enable_daily = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curNzbProvider, 'enable_manualsearch'):
try:
curNzbProvider.enable_manualsearch = config.checkbox_to_value(
kwargs['{id}_enable_manualsearch'.format(id=curNzbProvider.get_id())])
except (AttributeError, KeyError):
curNzbProvider.enable_manualsearch = 0 # these exceptions are actually catching unselected checkboxes
if hasattr(curNzbProvider, 'enable_backlog'):
try:
curNzbProvider.enable_backlog = config.checkbox_to_value(
kwargs['{id}_enable_backlog'.format(id=curNzbProvider.get_id())])
except (AttributeError, KeyError):
curNzbProvider.enable_backlog = 0 # these exceptions are actually catching unselected checkboxes
sickbeard.NEWZNAB_DATA = '!!!'.join([x.configStr() for x in sickbeard.newznabProviderList])
sickbeard.PROVIDER_ORDER = provider_list
sickbeard.save_config()
if results:
for x in results:
logger.log(x, logger.ERROR)
ui.notifications.error('Error(s) Saving Configuration',
'<br>\n'.join(results))
else:
ui.notifications.message('Configuration Saved', ek(os.path.join, sickbeard.CONFIG_FILE))
return self.redirect('/config/providers/')
def saveProviders(self, newznab_string='', torrentrss_string='', provider_order=None, **kwargs):
newznabProviderDict = dict(
zip((x.get_id() for x in sickbeard.newznabProviderList), sickbeard.newznabProviderList))
finished_names = []
# add all the newznab info we got into our list
# if not newznab_string:
# logger.log('No newznab_string passed to saveProviders', logger.DEBUG)
for curNewznabProviderStr in newznab_string.split('!!!'):
if not curNewznabProviderStr:
continue
cur_name, cur_url, cur_key, cur_cat = curNewznabProviderStr.split('|')
cur_url = config.clean_url(cur_url)
cur_id = GenericProvider.make_id(cur_name)
# if it does not already exist then add it
if cur_id not in newznabProviderDict:
new_provider = newznab.NewznabProvider(cur_name, cur_url, key=cur_key, catIDs=cur_cat)
sickbeard.newznabProviderList.append(new_provider)
newznabProviderDict[cur_id] = new_provider
# set all params
newznabProviderDict[cur_id].name = cur_name
newznabProviderDict[cur_id].url = cur_url
newznabProviderDict[cur_id].key = cur_key
newznabProviderDict[cur_id].catIDs = cur_cat
# a 0 in the key spot indicates that no key is needed
newznabProviderDict[cur_id].needs_auth = cur_key and cur_key != '0'
newznabProviderDict[cur_id].search_mode = str(kwargs.get(cur_id + '_search_mode', 'eponly')).strip()
newznabProviderDict[cur_id].search_fallback = config.checkbox_to_value(kwargs.get(cur_id + 'search_fallback', 0), value_on=1, value_off=0)
newznabProviderDict[cur_id].enable_daily = config.checkbox_to_value(kwargs.get(cur_id + 'enable_daily', 0), value_on=1, value_off=0)
newznabProviderDict[cur_id].enable_backlog = config.checkbox_to_value(kwargs.get(cur_id + 'enable_backlog', 0), value_on=1, value_off=0)
# mark it finished
finished_names.append(cur_id)
# delete anything that is in the list that was not processed just now
if newznab_string:
for curProvider in sickbeard.newznabProviderList:
if curProvider.get_id() not in finished_names:
sickbeard.newznabProviderList.remove(curProvider)
del newznabProviderDict[curProvider.get_id()]
# if not torrentrss_string:
# logger.log('No torrentrss_string passed to saveProviders', logger.DEBUG)
torrentRssProviderDict = dict(
zip((x.get_id() for x in sickbeard.torrentRssProviderList), sickbeard.torrentRssProviderList))
finished_names = []
if torrentrss_string:
for curTorrentRssProviderStr in torrentrss_string.split('!!!'):
if not curTorrentRssProviderStr:
continue
cur_name, cur_url, cur_cookies, cur_title_tag = curTorrentRssProviderStr.split('|')
cur_url = config.clean_url(cur_url)
cur_id = GenericProvider.make_id(cur_name)
# if it does not already exist then create it
if cur_id not in torrentRssProviderDict:
new_provider = rsstorrent.TorrentRssProvider(cur_name, cur_url, cur_cookies, cur_title_tag)
sickbeard.torrentRssProviderList.append(new_provider)
torrentRssProviderDict[cur_id] = new_provider
# update values
torrentRssProviderDict[cur_id].name = cur_name
torrentRssProviderDict[cur_id].url = cur_url
torrentRssProviderDict[cur_id].cookies = cur_cookies
torrentRssProviderDict[cur_id].cur_title_tag = cur_title_tag
# mark it finished
finished_names.append(cur_id)
# delete anything that is in the list that was not processed just now
if torrentrss_string:
for curProvider in sickbeard.torrentRssProviderList:
if curProvider.get_id() not in finished_names:
sickbeard.torrentRssProviderList.remove(curProvider)
del torrentRssProviderDict[curProvider.get_id()]
# do the enable/disable
enabled_provider_list = []
disabled_provider_list = []
for cur_id, cur_enabled in (cur_provider_str.split(':') for cur_provider_str in provider_order.split()):
cur_enabled = bool(try_int(cur_enabled))
cur_provider_obj = [x for x in sickbeard.providers.sortedProviderList() if x.get_id() == cur_id and hasattr(x, 'enabled')]
if cur_provider_obj:
cur_provider_obj[0].enabled = cur_enabled
if cur_enabled:
enabled_provider_list.append(cur_id)
else:
disabled_provider_list.append(cur_id)
if cur_id in newznabProviderDict:
newznabProviderDict[cur_id].enabled = cur_enabled
elif cur_id in torrentRssProviderDict:
torrentRssProviderDict[cur_id].enabled = cur_enabled
# dynamically load provider settings
for curProvider in sickbeard.providers.sortedProviderList():
if hasattr(curProvider, 'custom_url'):
curProvider.custom_url = str(kwargs.get(curProvider.get_id('_custom_url'), '')).strip()
if hasattr(curProvider, 'minseed'):
curProvider.minseed = int(str(kwargs.get(curProvider.get_id('_minseed'), 0)).strip())
if hasattr(curProvider, 'minleech'):
curProvider.minleech = int(str(kwargs.get(curProvider.get_id('_minleech'), 0)).strip())
if hasattr(curProvider, 'ratio'):
if curProvider.get_id('_ratio') in kwargs:
ratio = str(kwargs.get(curProvider.get_id('_ratio'))).strip()
print (ratio)
if ratio in ('None', None, ''):
curProvider.ratio = None
else:
curProvider.ratio = max(float(ratio), -1)
else:
curProvider.ratio = None
if hasattr(curProvider, 'digest'):
curProvider.digest = str(kwargs.get(curProvider.get_id('_digest'), '')).strip() or None
if hasattr(curProvider, 'hash'):
curProvider.hash = str(kwargs.get(curProvider.get_id('_hash'), '')).strip() or None
if hasattr(curProvider, 'api_key'):
curProvider.api_key = str(kwargs.get(curProvider.get_id('_api_key'), '')).strip() or None
if hasattr(curProvider, 'username'):
curProvider.username = str(kwargs.get(curProvider.get_id('_username'), '')).strip() or None
if hasattr(curProvider, 'password'):
curProvider.password = filters.unhide(curProvider.password, str(kwargs.get(curProvider.get_id('_password'), '')).strip())
if hasattr(curProvider, 'passkey'):
curProvider.passkey = filters.unhide(curProvider.passkey, str(kwargs.get(curProvider.get_id('_passkey'), '')).strip())
if hasattr(curProvider, 'pin'):
curProvider.pin = filters.unhide(curProvider.pin, str(kwargs.get(curProvider.get_id('_pin'), '')).strip())
if hasattr(curProvider, 'confirmed'):
curProvider.confirmed = config.checkbox_to_value(kwargs.get(curProvider.get_id('_confirmed')))
if hasattr(curProvider, 'ranked'):
curProvider.ranked = config.checkbox_to_value(kwargs.get(curProvider.get_id('_ranked')))
if hasattr(curProvider, 'engrelease'):
curProvider.engrelease = config.checkbox_to_value(kwargs.get(curProvider.get_id('_engrelease')))
if hasattr(curProvider, 'onlyspasearch'):
curProvider.onlyspasearch = config.checkbox_to_value(kwargs.get(curProvider.get_id('_onlyspasearch')))
if hasattr(curProvider, 'sorting'):
curProvider.sorting = str(kwargs.get(curProvider.get_id('_sorting'), 'seeders')).strip()
if hasattr(curProvider, 'freeleech'):
curProvider.freeleech = config.checkbox_to_value(kwargs.get(curProvider.get_id('_freeleech')))
if hasattr(curProvider, 'search_mode'):
curProvider.search_mode = str(kwargs.get(curProvider.get_id('_search_mode'), 'eponly')).strip()
if hasattr(curProvider, 'search_fallback'):
curProvider.search_fallback = config.checkbox_to_value(kwargs.get(curProvider.get_id('_search_fallback')))
if hasattr(curProvider, 'enable_daily'):
curProvider.enable_daily = curProvider.can_daily and config.checkbox_to_value(kwargs.get(curProvider.get_id('_enable_daily')))
if hasattr(curProvider, 'enable_backlog'):
curProvider.enable_backlog = curProvider.can_backlog and config.checkbox_to_value(kwargs.get(curProvider.get_id('_enable_backlog')))
if hasattr(curProvider, 'cat'):
curProvider.cat = int(str(kwargs.get(curProvider.get_id('_cat'), 0)).strip())
if hasattr(curProvider, 'subtitle'):
curProvider.subtitle = config.checkbox_to_value(kwargs.get(curProvider.get_id('_subtitle')))
if curProvider.enable_cookies:
curProvider.cookies = str(kwargs.get(curProvider.get_id('_cookies'))).strip()
sickbeard.NEWZNAB_DATA = '!!!'.join([x.configStr() for x in sickbeard.newznabProviderList])
sickbeard.PROVIDER_ORDER = enabled_provider_list + disabled_provider_list
sickbeard.save_config()
# Add a site_message if no providers are enabled for daily and/or backlog
sickbeard.providers.check_enabled_providers()
ui.notifications.message(_('Configuration Saved'), ek(os.path.join, sickbeard.CONFIG_FILE))
return self.redirect("/config/providers/")