def mass_notify_login(ipaddress):
if sickrage.app.config.notify_on_login and not is_ip_private(ipaddress):
for n in sickrage.app.notifier_providers.values():
try:
n.notify_login(ipaddress)
except Exception:
continue
def cleanup_provider_cache(self):
for item in self.all('providers'):
if int(item["quality"]) == Quality.UNKNOWN:
self.delete(item)
elif not validate_url(item["url"]) and not item["url"].startswith("magnet") \
or is_ip_private(item["url"].split(r'//')[-1].split(r'/')[0]):
self.delete(item)
def mass_notify_login(ipaddress):
if sickrage.app.config.general.notify_on_login and not is_ip_private(ipaddress):
for n in sickrage.app.notification_providers.values():
try:
n.notify_login(ipaddress)
except Exception:
continue
def notify_login(ipaddress):
if sickrage.app.config.notify_on_login and not is_ip_private(ipaddress):
for n in sickrage.app.notifier_providers.values():
try:
n._notify_login(ipaddress)
except:
continue
def cleanup_provider_cache(self):
for item in self.all('providers'):
if int(item["quality"]) == Quality.UNKNOWN:
self.delete(item)
elif not validate_url(item["url"]) and not item["url"].startswith("magnet") \
or is_ip_private(item["url"].split(r'//')[-1].split(r'/')[0]):
self.delete(item)
def addCacheEntry(self, name, url, seeders, leechers, size):
# check for existing entry in cache
if len([x for x in sickrage.app.cache_db.get_many('providers', self.providerID) if x['url'] == url]):
return
# ignore invalid urls
if not validate_url(url) and not url.startswith('magnet') \
or is_ip_private(url.split(r'//')[-1].split(r'/')[0]):
return
try:
# parse release name
parse_result = NameParser(validate_show=sickrage.app.config.enable_rss_cache_valid_shows).parse(name)
if parse_result.series_name and parse_result.quality != Quality.UNKNOWN:
season = parse_result.season_number if parse_result.season_number else 1
episodes = parse_result.episode_numbers
if season and episodes:
# store episodes as a seperated string
episodeText = "|" + "|".join(map(str, episodes)) + "|"
# get quality of release
quality = parse_result.quality
# get release group
release_group = parse_result.release_group
# get version
version = parse_result.version
dbData = {
'_t': 'providers',
'provider': self.providerID,
'name': name,
'season': season,
'episodes': episodeText,
'indexerid': parse_result.indexerid,
'url': url,
'time': int(time.mktime(datetime.datetime.today().timetuple())),
'quality': quality,
'release_group': release_group,
'version': version,
'seeders': seeders,
'leechers': leechers,
'size': size
}
# add to internal database
sickrage.app.cache_db.insert(dbData)
# add to external provider cache database
if sickrage.app.config.enable_api_providers_cache and not self.provider.private:
try:
sickrage.app.api.add_provider_cache_result(dbData)
except Exception:
pass
sickrage.app.log.debug("SEARCH RESULT:[%s] ADDED TO CACHE!", name)
except (InvalidShowException, InvalidNameException):
pass
def search_cache(self, ep_obj, manualSearch=False, downCurQuality=False):
neededEps = {}
dbData = []
# get data from external database
if sickrage.app.config.enable_api_providers_cache and not self.provider.private:
try:
dbData += ProviderCacheAPI().get(self.providerID,
ep_obj.show.indexerid,
ep_obj.season,
ep_obj.episode)['data']
except Exception:
pass
# get data from internal database
dbData += [
x for x in sickrage.app.cache_db.get_many('providers',
self.providerID)
]
# for each cache entry
for curResult in (x for x in dbData
if x['indexerid'] == ep_obj.show.indexerid
and x['season'] == ep_obj.season and "|" +
str(ep_obj.episode) + "|" in x['episodes']):
result = self.provider.getResult()
# ignore invalid urls
if not validate_url(curResult["url"]) and not curResult["url"].startswith('magnet') \
or is_ip_private(curResult["url"].split(r'//')[-1].split(r'/')[0]):
continue
# ignored/required words, and non-tv junk
if not show_names.filterBadReleases(curResult["name"]):
continue
# get the show object, or if it's not one of our shows then ignore it
result.show = findCertainShow(int(curResult["indexerid"]))
if not result.show:
continue
# skip if provider is anime only and show is not anime
if self.provider.anime_only and not result.show.is_anime:
sickrage.app.log.debug("" + str(result.show.name) +
" is not an anime, skiping")
continue
# get season and ep data (ignoring multi-eps for now)
curSeason = int(curResult["season"])
if curSeason == -1:
continue
try:
result.episodes = [
result.show.getEpisode(curSeason, int(curEp))
for curEp in filter(None, curResult["episodes"].split("|"))
]
except EpisodeNotFoundException:
continue
result.quality = int(curResult["quality"])
result.release_group = curResult["release_group"]
result.version = curResult["version"]
# make sure we want the episode
wantEp = False
for curEp in result.episodes:
if result.show.wantEpisode(curEp.season, curEp.episode,
result.quality, manualSearch,
downCurQuality):
wantEp = True
if not wantEp:
sickrage.app.log.info(
"Skipping " + curResult["name"] +
" because we don't want an episode that's " +
Quality.qualityStrings[result.quality])
continue
# build a result object
result.name = curResult["name"]
result.url = curResult["url"]
sickrage.app.log.info("Found result " + result.name + " at " +
result.url)
result.seeders = curResult.get("seeders", -1)
result.leechers = curResult.get("leechers", -1)
result.size = curResult.get("size", -1)
result.content = None
# add it to the list
if ep_obj.episode not in neededEps:
neededEps[ep_obj.episode] = [result]
else:
neededEps[ep_obj.episode] += [result]
# datetime stamp this search so cache gets cleared
self.last_search = datetime.datetime.today()
return neededEps
def search_cache(self, show_id, season, episode, manualSearch=False, downCurQuality=False):
cache_results = {}
dbData = []
# get data from external database
if sickrage.app.config.enable_api_providers_cache and not self.provider.private:
try:
dbData += sickrage.app.api.provider_cache.get(self.providerID, show_id, season, episode)['data']
except Exception:
pass
# get data from internal database
session = sickrage.app.cache_db.session()
dbData += [x.as_dict() for x in session.query(CacheDB.Provider).filter_by(provider=self.providerID, series_id=show_id, season=season).filter(
CacheDB.Provider.episodes.contains("|{}|".format(episode)))]
for curResult in dbData:
show_object = find_show(int(curResult["series_id"]))
if not show_object:
continue
result = self.provider.get_result()
# ignore invalid and private IP address urls
if not validate_url(curResult["url"]):
if not curResult["url"].startswith('magnet'):
continue
elif is_ip_private(curResult["url"].split(r'//')[-1].split(r'/')[0]):
continue
# ignored/required words, and non-tv junk
if not show_names.filter_bad_releases(curResult["name"]):
continue
# get the show object, or if it's not one of our shows then ignore it
result.show_id = int(curResult["series_id"])
# skip if provider is anime only and show is not anime
if self.provider.anime_only and not show_object.is_anime:
sickrage.app.log.debug("" + str(show_object.name) + " is not an anime, skiping")
continue
# get season and ep data (ignoring multi-eps for now)
curSeason = int(curResult["season"])
if curSeason == -1:
continue
result.season = curSeason
result.episodes = [int(curEp) for curEp in filter(None, curResult["episodes"].split("|"))]
result.quality = int(curResult["quality"])
result.release_group = curResult["release_group"]
result.version = curResult["version"]
# make sure we want the episode
wantEp = False
for result_episode in result.episodes:
if show_object.want_episode(result.season, result_episode, result.quality, manualSearch, downCurQuality):
wantEp = True
if not wantEp:
sickrage.app.log.info("Skipping " + curResult["name"] + " because we don't want an episode that's " + Quality.qualityStrings[result.quality])
continue
# build a result object
result.name = curResult["name"]
result.url = curResult["url"]
sickrage.app.log.info("Found cached {} result {}".format(result.type, result.name))
result.seeders = curResult.get("seeders", -1)
result.leechers = curResult.get("leechers", -1)
result.size = curResult.get("size", -1)
result.content = None
# add it to the list
if episode not in cache_results:
cache_results[int(episode)] = [result]
else:
cache_results[int(episode)] += [result]
# datetime stamp this search so cache gets cleared
self.last_search = datetime.datetime.today()
return cache_results
def add_cache_entry(self, name, url, seeders, leechers, size):
session = sickrage.app.cache_db.session()
# check for existing entry in cache
if session.query(CacheDB.Provider).filter_by(url=url).count():
return
# ignore invalid and private IP address urls
if not validate_url(url):
if not url.startswith('magnet'):
return
elif is_ip_private(url.split(r'//')[-1].split(r'/')[0]):
return
try:
# parse release name
parse_result = NameParser(validate_show=True).parse(name)
if parse_result.series_name and parse_result.quality != Quality.UNKNOWN:
season = parse_result.season_number if parse_result.season_number else 1
episodes = parse_result.episode_numbers
if season and episodes:
# store episodes as a seperated string
episodeText = "|" + "|".join(map(str, episodes)) + "|"
# get quality of release
quality = parse_result.quality
# get release group
release_group = parse_result.release_group
# get version
version = parse_result.version
dbData = {
'provider': self.providerID,
'name': name,
'season': season,
'episodes': episodeText,
'series_id': parse_result.indexer_id,
'url': url,
'time': int(time.mktime(datetime.datetime.today().timetuple())),
'quality': quality,
'release_group': release_group,
'version': version,
'seeders': try_int(seeders),
'leechers': try_int(leechers),
'size': try_int(size, -1)
}
# add to internal database
try:
session.add(CacheDB.Provider(**dbData))
session.commit()
sickrage.app.log.debug("SEARCH RESULT:[{}] ADDED TO CACHE!".format(name))
except IntegrityError:
pass
# add to external provider cache database
if sickrage.app.config.enable_api_providers_cache and not self.provider.private:
try:
sickrage.app.io_loop.run_in_executor(None, functools.partial(sickrage.app.api.provider_cache.add, data=dbData))
except Exception as e:
pass
except (InvalidShowException, InvalidNameException):
pass
def search_cache(self, ep_obj, manualSearch=False, downCurQuality=False):
season = ep_obj.scene_season if ep_obj.show.scene else ep_obj.season
episode = ep_obj.scene_episode if ep_obj.show.scene else ep_obj.episode
neededEps = {}
dbData = []
# get data from external database
if sickrage.app.config.enable_api_providers_cache and not self.provider.private:
try:
dbData += ProviderCacheAPI().get(self.providerID, ep_obj.show.indexerid, season, episode)['data']
except Exception:
pass
# get data from internal database
dbData += [x for x in sickrage.app.cache_db.get_many('providers', self.providerID)]
# for each cache entry
for curResult in (x for x in dbData if
x.get('indexerid') == ep_obj.show.indexerid and x.get('season') == season and "|{}|".format(
episode) in x.get('episodes', [])):
result = self.provider.getResult()
# ignore invalid and private IP address urls
if not validate_url(curResult["url"]):
if not curResult["url"].startswith('magnet'):
continue
elif is_ip_private(curResult["url"].split(r'//')[-1].split(r'/')[0]):
continue
# ignored/required words, and non-tv junk
if not show_names.filterBadReleases(curResult["name"]):
continue
# get the show object, or if it's not one of our shows then ignore it
result.show = findCertainShow(int(curResult["indexerid"]))
if not result.show:
continue
# skip if provider is anime only and show is not anime
if self.provider.anime_only and not result.show.is_anime:
sickrage.app.log.debug("" + str(result.show.name) + " is not an anime, skiping")
continue
# get season and ep data (ignoring multi-eps for now)
curSeason = int(curResult["season"])
if curSeason == -1:
continue
try:
result.episodes = [result.show.get_episode(curSeason, int(curEp)) for curEp in
filter(None, curResult["episodes"].split("|"))]
except EpisodeNotFoundException:
continue
result.quality = int(curResult["quality"])
result.release_group = curResult["release_group"]
result.version = curResult["version"]
# make sure we want the episode
wantEp = False
for curEp in result.episodes:
if result.show.want_episode(curEp.season,
curEp.episode,
result.quality,
manualSearch,
downCurQuality):
wantEp = True
if not wantEp:
sickrage.app.log.info("Skipping " + curResult["name"] + " because we don't want an episode that's " +
Quality.qualityStrings[result.quality])
continue
# build a result object
result.name = curResult["name"]
result.url = curResult["url"]
sickrage.app.log.info("Found result " + result.name + " at " + result.url)
result.seeders = curResult.get("seeders", -1)
result.leechers = curResult.get("leechers", -1)
result.size = curResult.get("size", -1)
result.content = None
# add it to the list
if ep_obj.episode not in neededEps:
neededEps[ep_obj.episode] = [result]
else:
neededEps[ep_obj.episode] += [result]
# datetime stamp this search so cache gets cleared
self.last_search = datetime.datetime.today()
return neededEps
def addCacheEntry(self, name, url, seeders, leechers, size):
# check for existing entry in cache
if len([x for x in sickrage.app.cache_db.get_many('providers', self.providerID) if x.get('url') == url]):
return
# ignore invalid and private IP address urls
if not validate_url(url):
if not url.startswith('magnet'):
return
elif is_ip_private(url.split(r'//')[-1].split(r'/')[0]):
return
try:
# parse release name
parse_result = NameParser(validate_show=True).parse(name)
if parse_result.series_name and parse_result.quality != Quality.UNKNOWN:
season = parse_result.season_number if parse_result.season_number else 1
episodes = parse_result.episode_numbers
if season and episodes:
# store episodes as a seperated string
episodeText = "|" + "|".join(map(str, episodes)) + "|"
# get quality of release
quality = parse_result.quality
# get release group
release_group = parse_result.release_group
# get version
version = parse_result.version
dbData = {
'_t': 'providers',
'provider': self.providerID,
'name': name,
'season': season,
'episodes': episodeText,
'indexerid': parse_result.indexerid,
'url': url,
'time': int(time.mktime(datetime.datetime.today().timetuple())),
'quality': quality,
'release_group': release_group,
'version': version,
'seeders': try_int(seeders),
'leechers': try_int(leechers),
'size': try_int(size, -1)
}
# add to internal database
sickrage.app.cache_db.insert(dbData)
# add to external provider cache database
if sickrage.app.config.enable_api_providers_cache and not self.provider.private:
try:
sickrage.app.event_queue.fire_event(ProviderCacheAPI().add, data=dbData)
except Exception:
pass
sickrage.app.log.debug("SEARCH RESULT:[%s] ADDED TO CACHE!", name)
except (InvalidShowException, InvalidNameException):
pass
