def post(self, series_slug): """Rename list of episodes" --- tags: [Series] summary: Rename list of episodes description: Rename list of episodes parameters: - in: path schema: SeriesSlugPath responses: 200: description: Success payload content: application/json: schema: EpisodesRenameSuccessSchema 400: description: Bad request; Check `errors` for any validation errors content: application/json: schema: BadRequestSchema 401: description: Returned if your JWT token is missing or expired content: application/json: schema: NotAuthorizedSchema """ data = json_decode(self.request.body) renamed_episodes = [] series = find_show_by_slug(series_slug) if series is None: return self._not_found( error= f"Unable to find the specified series using slug: {series_slug}" ) if not os.path.isdir(series.location): return self._bad_request( error= "Can't rename episodes when the show location does not exist") for episode_id in data.get('episodeIdList', []): episode = find_episode(episode_id, series.series_provider_id) if episode: episode.rename() renamed_episodes.append(episode.episode_id) if len(renamed_episodes) > 0: WebSocketMessage('SHOW_RENAMED', { 'seriesSlug': series.slug }).push() return self.json_response(renamed_episodes)
def get(self, series_slug=None): """Get list of series or specific series information" --- tags: [Series] summary: Manually search for episodes on search providers description: Manually search for episodes on search providers parameters: - in: path schema: SeriesPath responses: 200: description: Success payload content: application/json: schema: SeriesSuccessSchema 400: description: Bad request; Check `errors` for any validation errors content: application/json: schema: BadRequestSchema 401: description: Returned if your JWT token is missing or expired content: application/json: schema: NotAuthorizedSchema 404: description: Returned if the given series slug does not exist or no series results. content: application/json: schema: NotFoundSchema """ if not series_slug: all_series = {} for show in get_show_list(): if sickrage.app.show_queue.is_being_removed(show.series_id): continue all_series[show.slug] = show.to_json(progress=True) return self.write_json(all_series) series = find_show_by_slug(series_slug) if series is None: return self.send_error( 404, error= f"Unable to find the specified series using slug: {series_slug}" ) return self.write_json(series.to_json(episodes=True, details=True))
def get(self, series_slug, *args, **kwargs): series = find_show_by_slug(series_slug) if series is None: return self._not_found( error= f"Unable to find the specified series using slug: {series_slug}" ) image = series_image(series.series_id, series.series_provider_id, SeriesImageType.POSTER_THUMB) return self.json_response({'poster': image.url})
def get(self, series_slug, *args, **kwargs): series = find_show_by_slug(series_slug) if series is None: return self._not_found( error= f"Unable to find the specified series using slug: {series_slug}" ) episodes = [] for episode in series.episodes: episodes.append(episode.to_json()) return self.json_response(episodes)
def get(self, series_slug, *args, **kwargs): series = find_show_by_slug(series_slug) if series is None: return self.send_error( 404, error= f"Unable to find the specified series using slug: {series_slug}" ) episodes = [] for episode in series.episodes: episodes.append(episode.to_json()) return self.write_json(episodes)
def get(self, series_slug, *args, **kwargs): series = find_show_by_slug(series_slug) if series is None: return self._not_found( error= f"Unable to find the specified series using slug: {series_slug}" ) with sickrage.app.main_db.session() as session: imdb_info = session.query(MainDB.IMDbInfo).filter_by( imdb_id=series.imdb_id).one_or_none() json_data = IMDbInfoSchema().dump(imdb_info) return self.json_response(json_data)
def get(self, series_slug, *args, **kwargs): series = find_show_by_slug(series_slug) if series is None: return self._not_found( error= f"Unable to find the specified series using slug: {series_slug}" ) with sickrage.app.main_db.session() as session: whitelist = session.query(MainDB.Whitelist).filter_by( series_id=series.series_id, series_provider_id=series.series_provider_id).one_or_none() json_data = WhitelistSchema().dump(whitelist) return self.json_response(json_data)
def delete(self, series_slug): data = json_decode(self.request.body) series = find_show_by_slug(series_slug) if series is None: return self._not_found( error= f"Unable to find the specified series using slug: {series_slug}" ) sickrage.app.show_queue.remove_show( series.series_id, series.series_provider_id, checkbox_to_value(data.get('delete'))) return self.json_response({'message': True})
def get(self, series_slug, *args, **kwargs): series = find_show_by_slug(series_slug) if series is None: return self.send_error( 404, error= f"Unable to find the specified series using slug: {series_slug}" ) with sickrage.app.main_db.session() as session: blacklist = session.query(MainDB.Blacklist).filter_by( series_id=series.series_id, series_provider_id=series.series_provider_id).one_or_none() json_data = BlacklistSchema().dump(blacklist) return self.write_json(json_data)
def get(self, series_slug): force = self.get_argument('force', None) series = find_show_by_slug(series_slug) if series is None: return self._not_found( error= f"Unable to find the specified series using slug: {series_slug}" ) try: sickrage.app.show_queue.update_show(series.series_id, series.series_provider_id, force=bool(force)) except CantUpdateShowException as e: return self._bad_request( error=_(f"Unable to update this show, error: {e}"))
def get(self, series_slug): force = self.get_argument('force', None) series = find_show_by_slug(series_slug) if series is None: return self.send_error( 404, error= f"Unable to find the specified series using slug: {series_slug}" ) try: sickrage.app.show_queue.refresh_show(series.series_id, series.series_provider_id, force=bool(force)) except CantUpdateShowException as e: return self.send_error( 400, error=_(f"Unable to refresh this show, error: {e}"))
def patch(self, series_slug): warnings, errors = [], [] do_update = False do_update_exceptions = False data = json_decode(self.request.body) series = find_show_by_slug(series_slug) if series is None: return self.send_error( 404, error= f"Unable to find the specified series using slug: {series_slug}" ) # if we changed the language then kick off an update if data.get('lang') is not None and data['lang'] != series.lang: do_update = True if data.get('paused') is not None: series.paused = checkbox_to_value(data['paused']) if data.get('anime') is not None: series.anime = checkbox_to_value(data['anime']) if data.get('scene') is not None: series.scene = checkbox_to_value(data['scene']) if data.get('searchFormat') is not None: series.search_format = SearchFormat[data['searchFormat']] if data.get('subtitles') is not None: series.subtitles = checkbox_to_value(data['subtitles']) if data.get('subUseSrMetadata') is not None: series.sub_use_sr_metadata = checkbox_to_value( data['subUseSrMetadata']) if data.get('defaultEpStatus') is not None: series.default_ep_status = int(data['defaultEpStatus']) if data.get('skipDownloaded') is not None: series.skip_downloaded = checkbox_to_value(data['skipDownloaded']) if data.get('sceneExceptions') is not None and set( data['sceneExceptions']) != set(series.scene_exceptions): do_update_exceptions = True if data.get('whitelist') is not None: shortwhitelist = short_group_names(data['whitelist']) series.release_groups.set_white_keywords(shortwhitelist) if data.get('blacklist') is not None: shortblacklist = short_group_names(data['blacklist']) series.release_groups.set_black_keywords(shortblacklist) if data.get('qualityPreset') is not None: try: new_quality = Qualities[data['qualityPreset']] except KeyError: new_quality = Quality.combine_qualities( [Qualities[x] for x in data['allowedQualities']], [Qualities[x] for x in data['preferredQualities']]) series.quality = new_quality if data.get('flattenFolders') is not None and bool( series.flatten_folders) != bool(data['flattenFolders']): series.flatten_folders = data['flattenFolders'] try: sickrage.app.show_queue.refresh_show(series.series_id, series.series_provider_id, True) except CantRefreshShowException as e: errors.append(_(f"Unable to refresh this show: {e}")) if data.get('language') is not None: series.lang = data['language'] if data.get('dvdOrder') is not None: series.dvd_order = checkbox_to_value(data['dvdOrder']) if data.get('rlsIgnoreWords') is not None: series.rls_ignore_words = data['rlsIgnoreWords'] if data.get('rlsRequireWords') is not None: series.rls_require_words = data['rlsRequireWords'] # series.search_delay = int(data['search_delay']) # if we change location clear the db of episodes, change it, write to db, and rescan if data.get('location') is not None and os.path.normpath( series.location) != os.path.normpath(data['location']): sickrage.app.log.debug( os.path.normpath(series.location) + " != " + os.path.normpath(data['location'])) if not os.path.isdir( data['location'] ) and not sickrage.app.config.general.create_missing_show_dirs: warnings.append( f"New location {data['location']} does not exist") # don't bother if we're going to update anyway elif not do_update: # change it try: series.location = data['location'] try: sickrage.app.show_queue.refresh_show( series.series_id, series.series_provider_id, True) except CantRefreshShowException as e: errors.append(_(f"Unable to refresh this show: {e}")) # grab updated info from TVDB # showObj.loadEpisodesFromSeriesProvider() # rescan the episodes in the new folder except NoNFOException: warnings.append( _(f"The folder at {data['location']} doesn't contain a tvshow.nfo - copy your files to that folder before you change the directory in SiCKRAGE." )) # force the update if do_update: try: sickrage.app.show_queue.update_show(series.series_id, series.series_provider_id, force=True) except CantUpdateShowException as e: errors.append(_(f"Unable to update show: {e}")) if do_update_exceptions: try: series.scene_exceptions = set( data['sceneExceptions'].split(',')) except CantUpdateShowException: warnings.append( _("Unable to force an update on scene exceptions of the show." )) # if do_update_scene_numbering: # try: # xem_refresh(series.series_id, series.series_provider_id, True) # except CantUpdateShowException: # warnings.append(_("Unable to force an update on scene numbering of the show.")) # commit changes to database series.save() return self.write_json(series.to_json(episodes=True, details=True))
def get(self): """Get list of episodes to rename" --- tags: [Episodes] summary: Get list of episodes to rename description: Get list of episodes to rename parameters: - in: query schema: EpisodesRenameSchema responses: 200: description: Success payload content: application/json: schema: EpisodesRenameSuccessSchema 400: description: Bad request; Check `errors` for any validation errors content: application/json: schema: BadRequestSchema 401: description: Returned if your JWT token is missing or expired content: application/json: schema: NotAuthorizedSchema """ series_slug = self.get_argument('seriesSlug', None) validation_errors = self._validate_schema(EpisodesRenameSchema, self.request.arguments) if validation_errors: return self.send_error(400, error=validation_errors) if not series_slug: return self.send_error(400, error="Missing series slug") rename_data = [] series = find_show_by_slug(series_slug) if series is None: return self.send_error(404, error=f"Unable to find the specified series using slug: {series_slug}") if not os.path.isdir(series.location): return self.send_error(400, error="Can't rename episodes when the show location does not exist") for episode in series.episodes: if not episode.location: continue current_location = episode.location[len(episode.show.location) + 1:] new_location = "{}.{}".format(episode.proper_path(), current_location.split('.')[-1]) if current_location != new_location: rename_data.append({ 'episodeId': episode.episode_id, 'season': episode.season, 'episode': episode.episode, 'currentLocation': current_location, 'newLocation': new_location, }) return self.write_json(rename_data)
def get(self, series_slug, episode_slug): """Episode Manual Search" --- tags: [Series] summary: Manually search for episode on search providers description: Manually search for episode on search providers parameters: - in: path schema: SeriesSlugPath - in: path schema: EpisodeSlugPath responses: 200: description: Success payload content: application/json: schema: EpisodesManualSearchSuccessSchema 400: description: Bad request; Check `errors` for any validation errors content: application/json: schema: BadRequestSchema 401: description: Returned if your JWT token is missing or expired content: application/json: schema: NotAuthorizedSchema 404: description: Returned if the given episode slug does not exist or the search returns no results. content: application/json: schema: NotFoundSchema """ use_existing_quality = self.get_argument('useExistingQuality', None) or False # validation_errors = self._validate_schema(SeriesEpisodesManualSearchPath, self.request.path) # if validation_errors: # return self._bad_request(error=validation_errors) # # validation_errors = self._validate_schema(SeriesEpisodesManualSearchSchema, self.request.arguments) # if validation_errors: # return self._bad_request(error=validation_errors) # series = find_show_by_slug(series_slug) if series is None: return self._not_found( error= f"Unable to find the specified series using slug: {series_slug}" ) match = re.match(r'^s(?P<season>\d+)e(?P<episode>\d+)$', episode_slug) season_num = match.group('season') episode_num = match.group('episode') episode = series.get_episode(int(season_num), int(episode_num), no_create=True) if episode is None: return self._bad_request( error= f"Unable to find the specified episode using slug: {episode_slug}" ) # make a queue item for it and put it on the queue ep_queue_item = ManualSearchTask(int(episode.show.series_id), episode.show.series_provider_id, int(episode.season), int(episode.episode), bool(use_existing_quality)) sickrage.app.search_queue.put(ep_queue_item) if not all([ep_queue_item.started, ep_queue_item.success]): return self.json_response({'success': True}) return self._not_found(error=_( f"Unable to find season {season_num} episode {episode_num} for show {series.name} on search providers" ))