def isNamingValid(pattern=None, multi=None, abd=False, sports=False, anime_type=None): if not pattern: return "invalid" # air by date shows just need one check, we don't need to worry about season folders if abd: is_valid = naming.check_valid_abd_naming(pattern) require_season_folders = False # sport shows just need one check, we don't need to worry about season folders elif sports: is_valid = naming.check_valid_sports_naming(pattern) require_season_folders = False else: # check validity of single and multi ep cases for the whole path is_valid = naming.check_valid_naming(pattern, try_int(multi, None), try_int(anime_type, None)) # check validity of single and multi ep cases for only the file name require_season_folders = naming.check_force_season_folders( pattern, try_int(multi, None), try_int(anime_type, None)) if is_valid and not require_season_folders: return "valid" elif is_valid and require_season_folders: return "seasonfolders" else: return "invalid"
def testNaming(pattern=None, multi=None, abd=False, sports=False, anime_type=None): result = naming.test_name(pattern, try_int(multi, None), abd, sports, try_int(anime_type, None)) result = ek(os.path.join, result[b'dir'], result[b'name']) return result
def testNaming(pattern=None, multi=None, abd=False, sports=False, anime_type=None): result = naming.test_name(pattern, try_int(multi, None), abd, sports, try_int(anime_type, None)) result = os.path.join(result["dir"], result["name"]) return result
def viewlog(self): min_level = try_int(self.get_body_argument('min_level', str(logger.INFO)), logger.INFO) log_filter = self.get_body_argument('log_filter', "<NONE>") log_search = self.get_body_argument('log_search', '') max_lines = try_int(self.get_body_argument('max_lines', str(500)), 500) data = sickchill.logger.log_data(min_level, log_filter, log_search, max_lines) t = PageTemplate(rh=self, filename="viewlogs.mako") return t.render( header=_("Log File"), title=_("Logs"), topmenu="system", log_data="".join(data), min_level=min_level, log_filter=log_filter, log_search=log_search, controller="errorlogs", action="viewlogs")
def setup(self, hosts=None, username=None, password=None): self._connections = [] for host in (x.strip() for x in (hosts or settings.KODI_HOST or "").split(",") if x.strip()): try: if ":" in host: bare_host, port = host.split(":") kodi = Kodi(bare_host, username or settings.KODI_USERNAME, password or settings.KODI_PASSWORD, port=try_int(port, 8080)) else: kodi = Kodi(host, username or settings.KODI_USERNAME, password or settings.KODI_PASSWORD) kodi.host = kodi.variables()["hostname"]["value"] try: server_name = kodi.Settings.GetSettingValue( setting="services.devicename")["result"]["value"] kodi.name = server_name except: pass if kodi not in self._connections: self._connections.append(kodi) except (URLError, RequestTimeout, KeyError, IndexError): pass
def index(self): level = try_int(self.get_query_argument('level', str(logger.ERROR)), logger.ERROR) t = PageTemplate(rh=self, filename="errorlogs.mako") return t.render(header=_("Logs & Errors"), title=_("Logs & Errors"), topmenu="system", submenu=self.__ErrorLogsMenu(level), logLevel=level, controller="errorlogs", action="index")
def clearerrors(self): level = try_int(self.get_query_argument("level", str(logger.ERROR)), logger.ERROR) if int(level) == logger.WARNING: classes.WarningViewer.clear() else: classes.ErrorViewer.clear() return self.redirect("/errorlogs/viewlog/")
def index(self, level=logger.ERROR): # pylint: disable=arguments-differ level = try_int(level, logger.ERROR) t = PageTemplate(rh=self, filename="errorlogs.mako") return t.render(header=_("Logs & Errors"), title=_("Logs & Errors"), topmenu="system", submenu=self.ErrorLogsMenu(level), logLevel=level, controller="errorlogs", action="index")
def post(self, *args, **kwargs): notifiers.notify_login(self.request.remote_ip) if self.get_argument('username', '') == sickbeard.WEB_USERNAME and self.get_argument('password', '') == sickbeard.WEB_PASSWORD: remember_me = (None, 30)[try_int(self.get_argument('remember_me', default=0), 0) > 0] self.set_secure_cookie('sickchill_user', sickbeard.API_KEY, expires_days=remember_me) logger.log('User logged into the SickChill web interface', logger.INFO) else: logger.log('User attempted a failed login to the SickChill web interface from IP: ' + self.request.remote_ip, logger.WARNING) self.redirect('/' + sickbeard.DEFAULT_PAGE + '/')
def index(self, limit=None): # pylint: disable=arguments-differ sickbeard.HISTORY_LIMIT = limit = try_int(limit or sickbeard.HISTORY_LIMIT or 100, 100) sickbeard.save_config() compact = [] data = self.history.get(limit) for row in data: action = { 'action': row[b'action'], 'provider': row[b'provider'], 'resource': row[b'resource'], 'time': row[b'date'] } # noinspection PyTypeChecker if not any((history[b'show_id'] == row[b'show_id'] and history[b'season'] == row[b'season'] and history[b'episode'] == row[b'episode'] and history[b'quality'] == row[b'quality']) for history in compact): history = { 'actions': [action], 'episode': row[b'episode'], 'quality': row[b'quality'], 'resource': row[b'resource'], 'season': row[b'season'], 'show_id': row[b'show_id'], 'show_name': row[b'show_name'] } compact.append(history) else: index = [ i for i, item in enumerate(compact) if item[b'show_id'] == row[b'show_id'] and item[b'season'] == row[b'season'] and item[b'episode'] == row[b'episode'] and item[b'quality'] == row[b'quality'] ][0] history = compact[index] history[b'actions'].append(action) history[b'actions'].sort(key=lambda x: x[b'time'], reverse=True) t = PageTemplate(rh=self, filename="history.mako") submenu = [ {'title': _('Remove Selected'), 'path': 'history/removeHistory', 'icon': 'fa fa-eraser', 'class': 'removehistory', 'confirm': False}, {'title': _('Clear History'), 'path': 'history/clearHistory', 'icon': 'fa fa-trash', 'class': 'clearhistory', 'confirm': True}, {'title': _('Trim History'), 'path': 'history/trimHistory', 'icon': 'fa fa-scissors', 'class': 'trimhistory', 'confirm': True}, ] return t.render(historyResults=data, compactResults=compact, limit=limit, submenu=submenu, title=_('History'), header=_('History'), topmenu="history", controller="history", action="index")
def post(self, next_=None): notifiers.notify_login(self.request.remote_ip) if self.get_body_argument('username', None) == sickbeard.WEB_USERNAME and self.get_body_argument('password', None) == sickbeard.WEB_PASSWORD: remember_me = (None, 30)[try_int(self.get_body_argument('remember_me'), 0) > 0] self.set_secure_cookie('sickchill_user', sickbeard.API_KEY, expires_days=remember_me) logger.log('User logged into the SickChill web interface', logger.INFO) else: logger.log('User attempted a failed login to the SickChill web interface from IP: ' + self.request.remote_ip, logger.WARNING) next_ = self.get_query_argument('next', next_) self.redirect(next_)
def setup(self, hosts=None, username=None, password=None): self._connections = [] for host in (x.strip() for x in (hosts or sickbeard.KODI_HOST or '').split(",") if x.strip()): try: if ':' in host: bare_host, port = host.split(':') kodi = Kodi(bare_host, username or sickbeard.KODI_USERNAME, password or sickbeard.KODI_PASSWORD, port=try_int(port, 8080)) else: kodi = Kodi(host, username or sickbeard.KODI_USERNAME, password or sickbeard.KODI_PASSWORD) kodi.host = kodi.variables()['hostname']['value'] kodi.name = kodi.Settings.GetSettingValue( setting="services.devicename")['result']['value'] if kodi not in self._connections: self._connections.append(kodi) except (URLError, RequestTimeout): pass
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 calendar(self): """ Provides a subscribeable URL for iCal subscriptions """ logger.info(f"Receiving iCal request from {self.request.remote_ip}") # Create a iCal string ical = 'BEGIN:VCALENDAR\r\n' ical += 'VERSION:2.0\r\n' ical += 'X-WR-CALNAME:SickChill\r\n' ical += 'X-WR-CALDESC:SickChill\r\n' ical += 'PRODID://SickChill Upcoming Episodes//\r\n' future_weeks = try_int(self.get_argument('future', '52'), 52) past_weeks = try_int(self.get_argument('past', '52'), 52) # Limit dates past_date = (datetime.date.today() + datetime.timedelta(weeks=-past_weeks)).toordinal() future_date = (datetime.date.today() + datetime.timedelta(weeks=future_weeks)).toordinal() # Get all the shows that are not paused and are currently on air (from kjoconnor Fork) main_db_con = db.DBConnection() # noinspection PyPep8 calendar_shows = main_db_con.select( "SELECT show_name, indexer_id, network, airs, runtime FROM tv_shows WHERE " "( status = 'Continuing' OR status = 'Returning Series' ) AND paused != '1'" ) for show in calendar_shows: # Get all episodes of this show airing between today and next month episode_list = main_db_con.select( "SELECT indexerid, name, season, episode, description, airdate FROM tv_episodes WHERE airdate >= ? AND airdate < ? AND showid = ?", (past_date, future_date, int(show["indexer_id"]))) utc = tz.gettz('GMT') for episode in episode_list: air_date_time = network_timezones.parse_date_time( episode['airdate'], show["airs"], show['network']).astimezone(utc) air_date_time_end = air_date_time + datetime.timedelta( minutes=try_int(show["runtime"], 60)) # Create event for episode ical += 'BEGIN:VEVENT\r\n' ical += f'DTSTART:{air_date_time.strftime("%Y%m%d")}T{air_date_time.strftime("%H%M%S")}Z\r\n' ical += f'DTEND:{air_date_time_end.strftime("%Y%m%d")}T{air_date_time_end.strftime("%H%M%S")}Z\r\n' if settings.CALENDAR_ICONS: ical += 'X-GOOGLE-CALENDAR-CONTENT-ICON:https://sickchill.github.io/images/ico/favicon-16.png\r\n' ical += 'X-GOOGLE-CALENDAR-CONTENT-DISPLAY:CHIP\r\n' ical += f'SUMMARY: {show["show_name"]} - {episode["season"]}x{episode["episode"]} - {episode["name"]}\r\n' ical += f'UID:SickChill-{datetime.date.today().isoformat()}-{show["show_name"].replace(" ", "-")}-S{episode["season"]}E{episode["episode"]}\r\n' ical += f'DESCRIPTION:{show["airs"] or "(Unknown airs)"} on {show["network"] or "Unknown network"}' if episode['description']: ical += f' \\n\\n {episode["description"].splitlines()[0]}' ical += '\r\nEND:VEVENT\r\n' # Ending the iCal ical += 'END:VCALENDAR' return ical
def addNewShow( self, whichSeries=None, indexerLang=None, rootDir=None, defaultStatus=None, quality_preset=None, anyQualities=None, bestQualities=None, season_folders=None, subtitles=None, subtitles_sr_metadata=None, fullShowPath=None, other_shows=None, skipShow=None, providedIndexer=None, anime=None, scene=None, blacklist=None, whitelist=None, defaultStatusAfter=None, ): """ Receive tvdb id, dir, and other options and create a show from them. If extra show dirs are provided then it forwards back to newShow, if not it goes to /home. """ if not indexerLang: indexerLang = settings.INDEXER_DEFAULT_LANGUAGE # grab our list of other dirs if given if not other_shows: other_shows = [] elif not isinstance(other_shows, list): other_shows = [other_shows] def finishAddShow(): # if there are no extra shows then go home if not other_shows: return self.redirect("/home/") # peel off the next one next_show_dir = other_shows[0] rest_of_show_dirs = other_shows[1:] # go to add the next show return self.newShow(next_show_dir, rest_of_show_dirs) # if we're skipping then behave accordingly if skipShow: return finishAddShow() # sanity check on our inputs if (not rootDir and not fullShowPath) or not whichSeries: return _( "Missing params, no Indexer ID or folder: {show_to_add} and {root_dir}/{show_path}" ).format(show_to_add=whichSeries, root_dir=rootDir, show_path=fullShowPath) # figure out what show we're adding and where series_pieces = whichSeries.split("|") if (whichSeries and rootDir) or (whichSeries and fullShowPath and len(series_pieces) > 1): if len(series_pieces) < 6: logger.error( "Unable to add show due to show selection. Not enough arguments: {0}" .format((repr(series_pieces)))) ui.notifications.error( _("Unknown error. Unable to add show due to problem with show selection." )) return self.redirect("/addShows/existingShows/") indexer = int(series_pieces[1]) indexer_id = int(series_pieces[3]) # Show name was sent in UTF-8 in the form show_name = xhtml_unescape(series_pieces[4]) else: # if no indexer was provided use the default indexer set in General settings if not providedIndexer: providedIndexer = settings.INDEXER_DEFAULT indexer = int(providedIndexer) indexer_id = int(whichSeries) show_name = os.path.basename( os.path.normpath(xhtml_unescape(fullShowPath))) # use the whole path if it's given, or else append the show name to the root dir to get the full show path if fullShowPath: show_dir = os.path.normpath(xhtml_unescape(fullShowPath)) extra_check_dir = show_dir else: folder_name = show_name s = sickchill.indexer.series_by_id(indexerid=indexer_id, indexer=indexer, language=indexerLang) if settings.ADD_SHOWS_WITH_YEAR and s.firstAired: try: year = "({0})".format( dateutil.parser.parse(s.firstAired).year) if year not in folder_name: folder_name = "{0} {1}".format(s.seriesName, year) except (TypeError, ValueError): logger.info( _("Could not append the show year folder for the show: {0}" ).format(folder_name)) show_dir = os.path.join( rootDir, sanitize_filename(xhtml_unescape(folder_name))) extra_check_dir = os.path.join( rootDir, sanitize_filename(xhtml_unescape(show_name))) # blanket policy - if the dir exists you should have used "add existing show" numbnuts if (os.path.isdir(show_dir) or os.path.isdir(extra_check_dir)) and not fullShowPath: ui.notifications.error( _("Unable to add show"), _("Folder {show_dir} exists already").format( show_dir=show_dir)) return self.redirect("/addShows/existingShows/") # don't create show dir if config says not to if settings.ADD_SHOWS_WO_DIR: logger.info("Skipping initial creation of " + show_dir + " due to config.ini setting") else: dir_exists = helpers.makeDir(show_dir) if not dir_exists: logger.exception("Unable to create the folder " + show_dir + ", can't add the show") ui.notifications.error( _("Unable to add show"), _("Unable to create the folder {show_dir}, can't add the show" ).format(show_dir=show_dir)) # Don't redirect to default page because user wants to see the new show return self.redirect("/home/") else: helpers.chmodAsParent(show_dir) # prepare the inputs for passing along scene = config.checkbox_to_value(scene) anime = config.checkbox_to_value(anime) season_folders = config.checkbox_to_value(season_folders) subtitles = config.checkbox_to_value(subtitles) subtitles_sr_metadata = config.checkbox_to_value(subtitles_sr_metadata) if whitelist: whitelist = short_group_names(whitelist) if blacklist: blacklist = short_group_names(blacklist) if not anyQualities: anyQualities = [] if not bestQualities or try_int(quality_preset, None): bestQualities = [] if not isinstance(anyQualities, list): anyQualities = [anyQualities] if not isinstance(bestQualities, list): bestQualities = [bestQualities] newQuality = Quality.combineQualities([int(q) for q in anyQualities], [int(q) for q in bestQualities]) # add the show settings.showQueueScheduler.action.add_show( indexer, indexer_id, showDir=show_dir, default_status=int(defaultStatus), quality=newQuality, season_folders=season_folders, lang=indexerLang, subtitles=subtitles, subtitles_sr_metadata=subtitles_sr_metadata, anime=anime, scene=scene, paused=None, blacklist=blacklist, whitelist=whitelist, default_status_after=int(defaultStatusAfter), root_dir=rootDir, ) ui.notifications.message( _("Show added"), _("Adding the specified show into {show_dir}").format( show_dir=show_dir)) return finishAddShow()
def addShowByID( self, indexer_id, show_name, indexer="TVDB", which_series=None, indexer_lang=None, root_dir=None, default_status=None, quality_preset=None, any_qualities=None, best_qualities=None, season_folders=None, subtitles=None, full_show_path=None, other_shows=None, skip_show=None, provided_indexer=None, anime=None, scene=None, blacklist=None, whitelist=None, default_status_after=None, default_season_folders=None, configure_show_options=None, ): if indexer != "TVDB": indexer_id = helpers.tvdbid_from_remote_id(indexer_id, indexer.upper()) if not indexer_id: logger.info( "Unable to to find tvdb ID to add {0}".format(show_name)) ui.notifications.error( "Unable to add {0}".format(show_name), "Could not add {0}. We were unable to locate the tvdb id at this time." .format(show_name)) return indexer_id = try_int(indexer_id) if indexer_id <= 0 or Show.find(settings.showList, indexer_id): return # Sanitize the parameter anyQualities and bestQualities. As these would normally be passed as lists any_qualities = any_qualities.split(",") if any_qualities else [] best_qualities = best_qualities.split(",") if best_qualities else [] # If configure_show_options is enabled let's use the provided settings if config.checkbox_to_value(configure_show_options): # prepare the inputs for passing along scene = config.checkbox_to_value(scene) anime = config.checkbox_to_value(anime) season_folders = config.checkbox_to_value(season_folders) subtitles = config.checkbox_to_value(subtitles) if whitelist: whitelist = short_group_names(whitelist) if blacklist: blacklist = short_group_names(blacklist) if not any_qualities: any_qualities = [] if not best_qualities or try_int(quality_preset, None): best_qualities = [] if not isinstance(any_qualities, list): any_qualities = [any_qualities] if not isinstance(best_qualities, list): best_qualities = [best_qualities] quality = Quality.combineQualities( [int(q) for q in any_qualities], [int(q) for q in best_qualities]) location = root_dir else: default_status = settings.STATUS_DEFAULT quality = settings.QUALITY_DEFAULT season_folders = settings.SEASON_FOLDERS_DEFAULT subtitles = settings.SUBTITLES_DEFAULT anime = settings.ANIME_DEFAULT scene = settings.SCENE_DEFAULT default_status_after = settings.STATUS_DEFAULT_AFTER if settings.ROOT_DIRS: root_dirs = settings.ROOT_DIRS.split("|") location = root_dirs[int(root_dirs[0]) + 1] else: location = None if not location: logger.info( "There was an error creating the show, no root directory setting found" ) return _("No root directories setup, please go back and add one.") show_name = sickchill.indexer[1].get_series_by_id( indexer_id, indexer_lang).seriesName show_dir = None if not show_name: ui.notifications.error(_("Unable to add show")) return self.redirect("/home/") # add the show settings.showQueueScheduler.action.add_show( indexer=1, indexer_id=indexer_id, showDir=show_dir, default_status=default_status, quality=quality, season_folders=season_folders, lang=indexer_lang, subtitles=subtitles, subtitles_sr_metadata=None, anime=anime, scene=scene, paused=None, blacklist=blacklist, whitelist=whitelist, default_status_after=default_status_after, root_dir=location, ) ui.notifications.message( _("Show added"), _("Adding the specified show {show_name}").format( show_name=show_name)) # done adding show return self.redirect("/home/")
def massEditSubmit(self, paused=None, default_ep_status=None, anime=None, sports=None, scene=None, season_folders=None, quality_preset=None, subtitles=None, air_by_date=None, anyQualities=None, bestQualities=None, toEdit=None, *args, **kwargs): dir_map = {} for cur_arg in filter(lambda x: x.startswith('orig_root_dir_'), kwargs): dir_map[kwargs[cur_arg]] = ek( six.text_type, kwargs[cur_arg.replace('orig_root_dir_', 'new_root_dir_')], 'utf-8') showIDs = toEdit.split("|") errors = [] for curShow in showIDs: curErrors = [] show_obj = Show.find(sickbeard.showList, int(curShow or 0)) if not show_obj: continue cur_root_dir = self.__gooey_path(show_obj._location, 'dirname') cur_show_dir = self.__gooey_path(show_obj._location, 'basename') if cur_root_dir and dir_map.get( cur_root_dir ) and cur_root_dir != dir_map.get(cur_root_dir): new_show_dir = ek(os.path.join, dir_map[cur_root_dir], cur_show_dir) logger.log("For show " + show_obj.name + " changing dir from " + show_obj._location + " to " + new_show_dir) else: new_show_dir = show_obj._location new_paused = ('off', 'on')[(paused == 'enable', show_obj.paused)[paused == 'keep']] new_default_ep_status = ( default_ep_status, show_obj.default_ep_status)[default_ep_status == 'keep'] new_anime = ('off', 'on')[(anime == 'enable', show_obj.anime)[anime == 'keep']] new_sports = ('off', 'on')[(sports == 'enable', show_obj.sports)[sports == 'keep']] new_scene = ('off', 'on')[(scene == 'enable', show_obj.scene)[scene == 'keep']] new_air_by_date = ( 'off', 'on')[(air_by_date == 'enable', show_obj.air_by_date)[air_by_date == 'keep']] new_season_folders = ('off', 'on')[( season_folders == 'enable', show_obj.season_folders)[season_folders == 'keep']] new_subtitles = ('off', 'on')[(subtitles == 'enable', show_obj.subtitles)[subtitles == 'keep']] if quality_preset == 'keep': anyQualities, bestQualities = Quality.splitQuality( show_obj.quality) elif try_int(quality_preset, None): bestQualities = [] exceptions_list = [] curErrors += self.editShow(curShow, new_show_dir, anyQualities, bestQualities, exceptions_list, defaultEpStatus=new_default_ep_status, season_folders=new_season_folders, paused=new_paused, sports=new_sports, subtitles=new_subtitles, anime=new_anime, scene=new_scene, air_by_date=new_air_by_date, directCall=True) if curErrors: logger.log("Errors: " + str(curErrors), logger.ERROR) errors.append( '<b>{0}:</b>\n<ul>'.format(show_obj.name) + ' '.join( ['<li>{0}</li>'.format(error) for error in curErrors]) + "</ul>") if len(errors) > 0: ui.notifications.error( _('{num_errors:d} error{plural} while saving changes:').format( num_errors=len(errors), plural="" if len(errors) == 1 else "s"), " ".join(errors)) return self.redirect("/manage/")
def saveProviders(self, newznab_string="", torrentrss_string="", provider_order=None, **kwargs): newznabProviderDict = { x.get_id(): x for x in settings.newznabProviderList } finished_names = [] # add all the newznab info we got into our list # if not newznab_string: # logger.debug('No newznab_string passed to saveProviders') 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) settings.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 settings.newznabProviderList: if curProvider.get_id() not in finished_names: settings.newznabProviderList.remove(curProvider) del newznabProviderDict[curProvider.get_id()] # if not torrentrss_string: # logger.debug('No torrentrss_string passed to saveProviders') torrentRssProviderDict = { x.get_id(): x for x in settings.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) settings.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 settings.torrentRssProviderList: if curProvider.get_id() not in finished_names: settings.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 sickchill.oldbeard.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 sickchill.oldbeard.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() 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() settings.NEWZNAB_DATA = "!!!".join( [x.configStr() for x in settings.newznabProviderList]) settings.PROVIDER_ORDER = enabled_provider_list + disabled_provider_list sickchill.start.save_config() # Add a site_message if no providers are enabled for daily and/or backlog sickchill.oldbeard.providers.check_enabled_providers() ui.notifications.message(_("Configuration Saved"), os.path.join(settings.CONFIG_FILE)) return self.redirect("/config/providers/")
def saveGeneral( self, log_nr=5, log_size=1, web_port=None, notify_on_login=None, web_log=None, encryption_version=None, web_ipv6=None, trash_remove_show=None, trash_rotate_logs=None, update_frequency=None, skip_removed_files=None, indexerDefaultLang='en', ep_default_deleted_status=None, launch_browser=None, showupdate_hour=3, web_username=None, api_key=None, indexer_default=None, timezone_display=None, cpu_preset='NORMAL', web_password=None, version_notify=None, enable_https=None, https_cert=None, https_key=None, handle_reverse_proxy=None, sort_article=None, auto_update=None, notify_on_update=None, proxy_setting=None, proxy_indexers=None, anon_redirect=None, git_path=None, git_remote=None, calendar_unprotected=None, calendar_icons=None, debug=None, ssl_verify=None, no_restart=None, coming_eps_missed_range=None, fuzzy_dating=None, trim_zero=None, date_preset=None, date_preset_na=None, time_preset=None, indexer_timeout=None, download_url=None, rootDir=None, theme_name=None, default_page=None, fanart_background=None, fanart_background_opacity=None, sickchill_background=None, sickchill_background_path=None, custom_css=None, custom_css_path=None, git_reset=None, git_username=None, git_token=None, display_all_seasons=None, gui_language=None, ignore_broken_symlinks=None, ended_shows_update_interval=None): results = [] if gui_language != sickbeard.GUI_LANG: if gui_language: # Selected language gettext.translation('messages', sickbeard.LOCALE_DIR, languages=[gui_language], codeset='UTF-8').install(unicode=1, names=["ngettext"]) else: # System default language gettext.install('messages', sickbeard.LOCALE_DIR, unicode=1, codeset='UTF-8', names=["ngettext"]) sickbeard.GUI_LANG = gui_language # Misc sickbeard.DOWNLOAD_URL = download_url sickbeard.INDEXER_DEFAULT_LANGUAGE = indexerDefaultLang sickbeard.EP_DEFAULT_DELETED_STATUS = ep_default_deleted_status sickbeard.SKIP_REMOVED_FILES = config.checkbox_to_value(skip_removed_files) sickbeard.LAUNCH_BROWSER = config.checkbox_to_value(launch_browser) config.change_showupdate_hour(showupdate_hour) config.change_version_notify(version_notify) sickbeard.AUTO_UPDATE = config.checkbox_to_value(auto_update) sickbeard.NOTIFY_ON_UPDATE = config.checkbox_to_value(notify_on_update) sickbeard.LOG_NR = log_nr sickbeard.LOG_SIZE = float(log_size) sickbeard.WEB_LOG = config.checkbox_to_value(web_log) sickbeard.TRASH_REMOVE_SHOW = config.checkbox_to_value(trash_remove_show) sickbeard.TRASH_ROTATE_LOGS = config.checkbox_to_value(trash_rotate_logs) sickbeard.IGNORE_BROKEN_SYMLINKS = config.checkbox_to_value(ignore_broken_symlinks) config.change_update_frequency(update_frequency) sickbeard.LAUNCH_BROWSER = config.checkbox_to_value(launch_browser) sickbeard.SORT_ARTICLE = config.checkbox_to_value(sort_article) sickbeard.CPU_PRESET = cpu_preset sickbeard.ANON_REDIRECT = anon_redirect sickbeard.PROXY_SETTING = proxy_setting sickbeard.PROXY_INDEXERS = config.checkbox_to_value(proxy_indexers) sickbeard.GIT_USERNAME = git_username tmp_git_token = filters.unhide(sickbeard.GIT_TOKEN, git_token) if sickbeard.GIT_TOKEN != tmp_git_token: # Re-Initializes sickbeard.gh, so a restart isn't necessary sickbeard.GIT_TOKEN = tmp_git_token setup_github() # sickbeard.GIT_RESET = config.checkbox_to_value(git_reset) # Force GIT_RESET sickbeard.GIT_RESET = 1 sickbeard.GIT_PATH = git_path sickbeard.GIT_REMOTE = git_remote sickbeard.CALENDAR_UNPROTECTED = config.checkbox_to_value(calendar_unprotected) sickbeard.CALENDAR_ICONS = config.checkbox_to_value(calendar_icons) sickbeard.NO_RESTART = config.checkbox_to_value(no_restart) sickbeard.DEBUG = config.checkbox_to_value(debug) logger.set_level() sickbeard.SSL_VERIFY = config.checkbox_to_value(ssl_verify) sickbeard.COMING_EPS_MISSED_RANGE = config.min_max(coming_eps_missed_range, 7, 0, 42810) sickbeard.DISPLAY_ALL_SEASONS = config.checkbox_to_value(display_all_seasons) sickbeard.NOTIFY_ON_LOGIN = config.checkbox_to_value(notify_on_login) sickbeard.WEB_PORT = try_int(web_port) sickbeard.WEB_IPV6 = config.checkbox_to_value(web_ipv6) sickbeard.ENCRYPTION_VERSION = config.checkbox_to_value(encryption_version, value_on=2, value_off=0) sickbeard.WEB_USERNAME = web_username sickbeard.WEB_PASSWORD = filters.unhide(sickbeard.WEB_PASSWORD, web_password) sickbeard.FUZZY_DATING = config.checkbox_to_value(fuzzy_dating) sickbeard.TRIM_ZERO = config.checkbox_to_value(trim_zero) if date_preset: sickbeard.DATE_PRESET = date_preset if indexer_default: sickbeard.INDEXER_DEFAULT = try_int(indexer_default) if indexer_timeout: sickbeard.INDEXER_TIMEOUT = try_int(indexer_timeout) if time_preset: sickbeard.TIME_PRESET_W_SECONDS = time_preset sickbeard.TIME_PRESET = time_preset.replace(":%S", "") sickbeard.TIMEZONE_DISPLAY = timezone_display sickbeard.API_KEY = api_key sickbeard.ENABLE_HTTPS = config.checkbox_to_value(enable_https) if not config.change_https_cert(https_cert): results += [ _("Unable to create directory {directory}, https cert directory not changed.").format(directory=ek(os.path.normpath, https_cert))] if not config.change_https_key(https_key): results += [ _("Unable to create directory {directory}, https key directory not changed.").format(directory=ek(os.path.normpath, https_key))] sickbeard.HANDLE_REVERSE_PROXY = config.checkbox_to_value(handle_reverse_proxy) sickbeard.THEME_NAME = theme_name sickbeard.SICKCHILL_BACKGROUND = config.checkbox_to_value(sickchill_background) config.change_sickchill_background(sickchill_background_path) sickbeard.FANART_BACKGROUND = config.checkbox_to_value(fanart_background) sickbeard.FANART_BACKGROUND_OPACITY = fanart_background_opacity sickbeard.CUSTOM_CSS = config.checkbox_to_value(custom_css) config.change_custom_css(custom_css_path) sickbeard.ENDED_SHOWS_UPDATE_INTERVAL = int(ended_shows_update_interval) sickbeard.DEFAULT_PAGE = default_page 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/general/")
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 massEditSubmit( self, paused=None, default_ep_status=None, anime=None, sports=None, scene=None, season_folders=None, quality_preset=None, subtitles=None, air_by_date=None, anyQualities=None, bestQualities=None, toEdit=None, *args, **kwargs, ): dir_map = {} for cur_arg in [x for x in kwargs if x.startswith("orig_root_dir_")]: dir_map[kwargs[cur_arg]] = kwargs[cur_arg.replace( "orig_root_dir_", "new_root_dir_")] showIDs = toEdit.split("|") errors = [] for curShow in showIDs: curErrors = [] show_obj = Show.find(settings.showList, int(curShow or 0)) if not show_obj: continue cur_root_dir = self.__gooey_path(show_obj._location, "dirname") cur_show_dir = self.__gooey_path(show_obj._location, "basename") if cur_root_dir and dir_map.get( cur_root_dir ) and cur_root_dir != dir_map.get(cur_root_dir): new_show_dir = os.path.join(dir_map[cur_root_dir], cur_show_dir) logger.info("For show " + show_obj.name + " changing dir from " + show_obj._location + " to " + new_show_dir) else: new_show_dir = show_obj._location new_paused = ("off", "on")[(paused == "enable", show_obj.paused)[paused == "keep"]] new_default_ep_status = ( default_ep_status, show_obj.default_ep_status)[default_ep_status == "keep"] new_anime = ("off", "on")[(anime == "enable", show_obj.anime)[anime == "keep"]] new_sports = ("off", "on")[(sports == "enable", show_obj.sports)[sports == "keep"]] new_scene = ("off", "on")[(scene == "enable", show_obj.scene)[scene == "keep"]] new_air_by_date = ( "off", "on")[(air_by_date == "enable", show_obj.air_by_date)[air_by_date == "keep"]] new_season_folders = ("off", "on")[( season_folders == "enable", show_obj.season_folders)[season_folders == "keep"]] new_subtitles = ("off", "on")[(subtitles == "enable", show_obj.subtitles)[subtitles == "keep"]] if quality_preset == "keep": anyQualities, bestQualities = Quality.splitQuality( show_obj.quality) elif try_int(quality_preset, None): bestQualities = [] exceptions_list = [] curErrors += self.editShow( curShow, new_show_dir, anyQualities, bestQualities, exceptions_list, defaultEpStatus=new_default_ep_status, season_folders=new_season_folders, paused=new_paused, sports=new_sports, subtitles=new_subtitles, anime=new_anime, scene=new_scene, air_by_date=new_air_by_date, directCall=True, ) if curErrors: logger.exception("Errors: " + str(curErrors)) errors.append( "<b>{0}:</b>\n<ul>".format(show_obj.name) + " ".join( ["<li>{0}</li>".format(error) for error in curErrors]) + "</ul>") if errors: ui.notifications.error( _("{num_errors:d} error{plural} while saving changes:").format( num_errors=len(errors), plural="" if len(errors) == 1 else "s"), " ".join(errors)) return self.redirect("/manage/")
def index(self, limit=None): settings.HISTORY_LIMIT = limit = try_int( limit or settings.HISTORY_LIMIT or 100, 100) sickchill.start.save_config() compact = [] data = self.history.get(limit) for row in data: action = { "action": row["action"], "provider": row["provider"], "resource": row["resource"], "time": row["date"] } if not any( (history["show_id"] == row["show_id"] and history["season"] == row["season"] and history["episode"] == row["episode"] and history["quality"] == row["quality"]) for history in compact): history = { "actions": [action], "episode": row["episode"], "quality": row["quality"], "resource": row["resource"], "season": row["season"], "show_id": row["show_id"], "show_name": row["show_name"], } compact.append(history) else: index = [ i for i, item in enumerate(compact) if item["show_id"] == row["show_id"] and item["season"] == row["season"] and item["episode"] == row["episode"] and item["quality"] == row["quality"] ][0] history = compact[index] history["actions"].append(action) history["actions"].sort(key=lambda x: x["time"], reverse=True) t = PageTemplate(rh=self, filename="history.mako") submenu = [ { "title": _("Remove Selected"), "path": "history/removeHistory", "icon": "fa fa-eraser", "class": "removehistory", "confirm": False }, { "title": _("Clear History"), "path": "history/clearHistory", "icon": "fa fa-trash", "class": "clearhistory", "confirm": True }, { "title": _("Trim History"), "path": "history/trimHistory", "icon": "fa fa-scissors", "class": "trimhistory", "confirm": True }, ] return t.render( historyResults=data, compactResults=compact, limit=limit, submenu=submenu, title=_("History"), header=_("History"), topmenu="history", controller="history", action="index", )
def calendar(self): """ Provides a subscribeable URL for iCal subscriptions """ logger.log("Receiving iCal request from {0}".format( self.request.remote_ip)) # Create a iCal string ical = 'BEGIN:VCALENDAR\r\n' ical += 'VERSION:2.0\r\n' ical += 'X-WR-CALNAME:SickChill\r\n' ical += 'X-WR-CALDESC:SickChill\r\n' ical += 'PRODID://Sick-Beard Upcoming Episodes//\r\n' future_weeks = try_int(self.get_argument('future', 52), 52) past_weeks = try_int(self.get_argument('past', 52), 52) # Limit dates past_date = (datetime.date.today() + datetime.timedelta(weeks=-past_weeks)).toordinal() future_date = (datetime.date.today() + datetime.timedelta(weeks=future_weeks)).toordinal() # Get all the shows that are not paused and are currently on air (from kjoconnor Fork) main_db_con = db.DBConnection() # noinspection PyPep8 calendar_shows = main_db_con.select( "SELECT show_name, indexer_id, network, airs, runtime FROM tv_shows WHERE ( status = 'Continuing' OR status = 'Returning Series' ) AND paused != '1'" ) for show in calendar_shows: # Get all episodes of this show airing between today and next month episode_list = main_db_con.select( "SELECT indexerid, name, season, episode, description, airdate FROM tv_episodes WHERE airdate >= ? AND airdate < ? AND showid = ?", (past_date, future_date, int(show[b"indexer_id"]))) utc = tz.gettz('GMT') for episode in episode_list: air_date_time = network_timezones.parse_date_time( episode[b'airdate'], show[b"airs"], show[b'network']).astimezone(utc) air_date_time_end = air_date_time + datetime.timedelta( minutes=try_int(show[b"runtime"], 60)) # Create event for episode ical += 'BEGIN:VEVENT\r\n' ical += 'DTSTART:' + air_date_time.strftime( "%Y%m%d") + 'T' + air_date_time.strftime( "%H%M%S") + 'Z\r\n' ical += 'DTEND:' + air_date_time_end.strftime( "%Y%m%d") + 'T' + air_date_time_end.strftime( "%H%M%S") + 'Z\r\n' if sickbeard.CALENDAR_ICONS: # noinspection PyPep8 ical += 'X-GOOGLE-CALENDAR-CONTENT-ICON:https://lh3.googleusercontent.com/-Vp_3ZosvTgg/VjiFu5BzQqI/AAAAAAAA_TY/3ZL_1bC0Pgw/s16-Ic42/SickChill.png\r\n' ical += 'X-GOOGLE-CALENDAR-CONTENT-DISPLAY:CHIP\r\n' ical += 'SUMMARY: {0} - {1}x{2} - {3}\r\n'.format( show[b'show_name'], episode[b'season'], episode[b'episode'], episode[b'name']) ical += 'UID:SickChill-' + str(datetime.date.today().isoformat()) + '-' + \ show[b'show_name'].replace(" ", "-") + '-E' + str(episode[b'episode']) + \ 'S' + str(episode[b'season']) + '\r\n' if episode[b'description']: ical += 'DESCRIPTION: {0} on {1} \\n\\n {2}\r\n'.format( (show[b'airs'] or '(Unknown airs)'), (show[b'network'] or 'Unknown network'), episode[b'description'].splitlines()[0]) else: ical += 'DESCRIPTION:' + ( show[b'airs'] or '(Unknown airs)') + ' on ' + ( show[b'network'] or 'Unknown network') + '\r\n' ical += 'END:VEVENT\r\n' # Ending the iCal ical += 'END:VCALENDAR' return ical
def savePostProcessing(self, kodi_data=None, kodi_12plus_data=None, mediabrowser_data=None, sony_ps3_data=None, wdtv_data=None, tivo_data=None, mede8er_data=None, keep_processed_dir=None, process_method=None, processor_follow_symlinks=None, del_rar_contents=None, process_automatically=None, no_delete=None, rename_episodes=None, airdate_episodes=None, file_timestamp_timezone=None, unpack=None, unpack_dir=None, unrar_tool=None, alt_unrar_tool=None, move_associated_files=None, delete_non_associated_files=None, sync_files=None, postpone_if_sync_files=None, allowed_extensions=None, tv_download_dir=None, create_missing_show_dirs=None, add_shows_wo_dir=None, extra_scripts=None, nfo_rename=None, naming_pattern=None, naming_multi_ep=None, naming_custom_abd=None, naming_anime=None, naming_abd_pattern=None, naming_strip_year=None, naming_custom_sports=None, naming_sports_pattern=None, naming_custom_anime=None, naming_anime_pattern=None, naming_anime_multi_ep=None, autopostprocessor_frequency=None, use_icacls=None): results = [] if not config.change_tv_download_dir(tv_download_dir): results += [ "Unable to create directory " + ek(os.path.normpath, tv_download_dir) + ", dir not changed." ] config.change_postprocessor_frequency(autopostprocessor_frequency) config.change_process_automatically(process_automatically) sickbeard.USE_ICACLS = config.checkbox_to_value(use_icacls) config.change_unrar_tool(unrar_tool, alt_unrar_tool) unpack = try_int(unpack) if unpack == sickbeard.UNPACK_PROCESS_CONTENTS: sickbeard.UNPACK = int(self.isRarSupported() != 'not supported') if sickbeard.UNPACK != sickbeard.UNPACK_PROCESS_CONTENTS: results.append( _("Unpacking Not Supported, disabling unpack setting")) elif unpack in sickbeard.unpackStrings: sickbeard.UNPACK = unpack if not config.change_unpack_dir(unpack_dir): results += [ "Unable to change unpack directory to " + ek(os.path.normpath, unpack_dir) + ", check the logs." ] sickbeard.NO_DELETE = config.checkbox_to_value(no_delete) sickbeard.KEEP_PROCESSED_DIR = config.checkbox_to_value( keep_processed_dir) sickbeard.CREATE_MISSING_SHOW_DIRS = config.checkbox_to_value( create_missing_show_dirs) sickbeard.ADD_SHOWS_WO_DIR = config.checkbox_to_value(add_shows_wo_dir) sickbeard.PROCESS_METHOD = process_method sickbeard.PROCESSOR_FOLLOW_SYMLINKS = config.checkbox_to_value( processor_follow_symlinks) sickbeard.DELRARCONTENTS = config.checkbox_to_value(del_rar_contents) sickbeard.EXTRA_SCRIPTS = [ x.strip() for x in extra_scripts.split('|') if x.strip() ] sickbeard.RENAME_EPISODES = config.checkbox_to_value(rename_episodes) sickbeard.AIRDATE_EPISODES = config.checkbox_to_value(airdate_episodes) sickbeard.FILE_TIMESTAMP_TIMEZONE = file_timestamp_timezone sickbeard.MOVE_ASSOCIATED_FILES = config.checkbox_to_value( move_associated_files) sickbeard.DELETE_NON_ASSOCIATED_FILES = config.checkbox_to_value( delete_non_associated_files) sickbeard.SYNC_FILES = sync_files sickbeard.POSTPONE_IF_SYNC_FILES = config.checkbox_to_value( postpone_if_sync_files) sickbeard.ALLOWED_EXTENSIONS = ','.join( {x.strip() for x in allowed_extensions.split(',') if x.strip()}) sickbeard.NAMING_CUSTOM_ABD = config.checkbox_to_value( naming_custom_abd) sickbeard.NAMING_CUSTOM_SPORTS = config.checkbox_to_value( naming_custom_sports) sickbeard.NAMING_CUSTOM_ANIME = config.checkbox_to_value( naming_custom_anime) sickbeard.NAMING_STRIP_YEAR = config.checkbox_to_value( naming_strip_year) sickbeard.NFO_RENAME = config.checkbox_to_value(nfo_rename) sickbeard.METADATA_KODI = kodi_data sickbeard.METADATA_KODI_12PLUS = kodi_12plus_data sickbeard.METADATA_MEDIABROWSER = mediabrowser_data sickbeard.METADATA_PS3 = sony_ps3_data sickbeard.METADATA_WDTV = wdtv_data sickbeard.METADATA_TIVO = tivo_data sickbeard.METADATA_MEDE8ER = mede8er_data sickbeard.metadata_provider_dict['KODI'].set_config( sickbeard.METADATA_KODI) sickbeard.metadata_provider_dict['KODI 12+'].set_config( sickbeard.METADATA_KODI_12PLUS) sickbeard.metadata_provider_dict['MediaBrowser'].set_config( sickbeard.METADATA_MEDIABROWSER) sickbeard.metadata_provider_dict['Sony PS3'].set_config( sickbeard.METADATA_PS3) sickbeard.metadata_provider_dict['WDTV'].set_config( sickbeard.METADATA_WDTV) sickbeard.metadata_provider_dict['TIVO'].set_config( sickbeard.METADATA_TIVO) sickbeard.metadata_provider_dict['Mede8er'].set_config( sickbeard.METADATA_MEDE8ER) if self.isNamingValid(naming_pattern, naming_multi_ep, anime_type=naming_anime) != "invalid": sickbeard.NAMING_PATTERN = naming_pattern sickbeard.NAMING_MULTI_EP = try_int( naming_multi_ep, NAMING_LIMITED_EXTEND_E_PREFIXED) sickbeard.NAMING_FORCE_FOLDERS = naming.check_force_season_folders( ) else: results.append( _("You tried saving an invalid normal naming config, not saving your naming settings" )) if self.isNamingValid(naming_anime_pattern, naming_anime_multi_ep, anime_type=naming_anime) != "invalid": sickbeard.NAMING_ANIME_PATTERN = naming_anime_pattern sickbeard.NAMING_ANIME_MULTI_EP = try_int( naming_anime_multi_ep, NAMING_LIMITED_EXTEND_E_PREFIXED) sickbeard.NAMING_ANIME = try_int(naming_anime, 3) sickbeard.NAMING_FORCE_FOLDERS = naming.check_force_season_folders( ) else: results.append( _("You tried saving an invalid anime naming config, not saving your naming settings" )) if self.isNamingValid(naming_abd_pattern, None, abd=True) != "invalid": sickbeard.NAMING_ABD_PATTERN = naming_abd_pattern else: results.append( "You tried saving an invalid air-by-date naming config, not saving your air-by-date settings" ) if self.isNamingValid(naming_sports_pattern, None, sports=True) != "invalid": sickbeard.NAMING_SPORTS_PATTERN = naming_sports_pattern else: results.append( "You tried saving an invalid sports naming config, not saving your sports settings" ) sickbeard.save_config() if results: for x in results: logger.log(x, logger.WARNING) 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/postProcessing/")
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/")