def add(self, attrs={}, update_after=True):
db = get_session()
l = db.query(Library).filter_by(
identifier=attrs.get('identifier')).first()
if not l:
status = fireEvent('status.get', 'needs_update', single=True)
l = Library(year=attrs.get('year'),
identifier=attrs.get('identifier'),
plot=attrs.get('plot'),
tagline=attrs.get('tagline'),
status_id=status.get('id'))
title = LibraryTitle(title=attrs.get('title'))
l.titles.append(title)
db.add(l)
db.commit()
# Update library info
if update_after:
fireEventAsync('library.update',
identifier=l.identifier,
default_title=attrs.get('title', ''))
return l.to_dict(self.default_dict)
def add(self):
params = getParams()
db = get_session()
library = fireEvent('library.add', single=True, attrs=params)
status = fireEvent('status.add', 'active', single=True)
m = db.query(Movie).filter_by(library_id=library.id).first()
if not m:
m = Movie(library_id=library.id,
profile_id=params.get('profile_id'))
db.add(m)
m.status_id = status.id
db.commit()
return jsonified({
'success':
True,
'added':
True,
'movie':
m.to_dict(
deep={
'releases': {
'status': {},
'quality': {}
},
'library': {
'titles': {}
}
})
})
def onComplete():
db = get_session()
show = db.query(Media).filter_by(id=show_id).first()
fireEventAsync('show.searcher.single',
show.to_dict(self.default_dict),
on_complete=self.createNotifyFront(show_id))
db.expire_all()
def restatus(self, movie_id):
active_status, done_status = fireEvent('status.get', ['active', 'done'], single = True)
db = get_session()
m = db.query(Movie).filter_by(id = movie_id).first()
if not m or len(m.library.titles) == 0:
log.debug('Can\'t restatus movie, doesn\'t seem to exist.')
return False
log.debug('Changing status for %s', (m.library.titles[0].title))
if not m.profile:
m.status_id = done_status.get('id')
else:
move_to_wanted = True
for t in m.profile.types:
for release in m.releases:
if t.quality.identifier is release.quality.identifier and (release.status_id is done_status.get('id') and t.finish):
move_to_wanted = False
m.status_id = active_status.get('id') if move_to_wanted else done_status.get('id')
db.commit()
return True
def updateSuggestionCache(self, ignore_imdb = None, limit = 6, ignored = None, seen = None):
# Combine with previous suggestion_cache
cached_suggestion = self.getCache('suggestion_cached') or []
new_suggestions = []
ignored = [] if not ignored else ignored
seen = [] if not seen else seen
if ignore_imdb:
for cs in cached_suggestion:
if cs.get('imdb') != ignore_imdb:
new_suggestions.append(cs)
# Get new results and add them
if len(new_suggestions) - 1 < limit:
active_status, done_status = fireEvent('status.get', ['active', 'done'], single = True)
db = get_session()
active_movies = db.query(Movie) \
.join(Library) \
.with_entities(Library.identifier) \
.filter(Movie.status_id.in_([active_status.get('id'), done_status.get('id')])).all()
movies = [x[0] for x in active_movies]
movies.extend(seen)
ignored.extend([x.get('imdb') for x in cached_suggestion])
suggestions = fireEvent('movie.suggest', movies = movies, ignore = list(set(ignored)), single = True)
if suggestions:
new_suggestions.extend(suggestions)
self.setCache('suggestion_cached', new_suggestions, timeout = 3024000)
return new_suggestions
def add(self, group):
db = get_session()
identifier = '%s.%s.%s' % (group['library']['identifier'],
group['meta_data'].get('audio', 'unknown'),
group['meta_data']['quality']['identifier'])
done_status, snatched_status = fireEvent('status.get',
['done', 'snatched'],
single=True)
# Add movie
movie = db.query(Media).filter_by(
library_id=group['library'].get('id')).first()
if not movie:
movie = Media(library_id=group['library'].get('id'),
profile_id=0,
status_id=done_status.get('id'))
db.add(movie)
db.commit()
# Add Release
rel = db.query(Relea).filter(
or_(
Relea.identifier == identifier,
and_(
Relea.identifier.startswith(
group['library']['identifier']),
Relea.status_id == snatched_status.get('id')))).first()
if not rel:
rel = Relea(identifier=identifier,
movie=movie,
quality_id=group['meta_data']['quality'].get('id'),
status_id=done_status.get('id'))
db.add(rel)
db.commit()
# Add each file type
added_files = []
for type in group['files']:
for cur_file in group['files'][type]:
added_file = self.saveFile(cur_file,
type=type,
include_media_info=type is 'movie')
added_files.append(added_file.get('id'))
# Add the release files in batch
try:
added_files = db.query(File).filter(
or_(*[File.id == x for x in added_files])).all()
rel.files.extend(added_files)
db.commit()
except:
log.debug('Failed to attach "%s" to release: %s',
(added_files, traceback.format_exc()))
fireEvent('movie.restatus', movie.id)
return True
def edit(self):
params = getParams()
db = get_session()
available_status = fireEvent('status.get', 'available', single = True)
ids = params.get('id').split(',')
for movie_id in ids:
m = db.query(Movie).filter_by(id = movie_id).first()
m.profile_id = params.get('profile_id')
# Remove releases
for rel in m.releases:
if rel.status_id is available_status.get('id'):
db.delete(rel)
db.commit()
# Default title
if params.get('default_title'):
for title in m.library.titles:
title.default = params.get('default_title').lower() == title.title.lower()
db.commit()
fireEvent('movie.restatus', m.id)
movie_dict = m.to_dict(self.default_dict)
fireEventAsync('searcher.single', movie_dict)
return jsonified({
'success': True,
})
def tryNextRelease(self, media_id, manual=False):
snatched_status, done_status, ignored_status = fireEvent(
'status.get', ['snatched', 'done', 'ignored'], single=True)
try:
db = get_session()
rels = db.query(Release) \
.filter_by(movie_id = media_id) \
.filter(Release.status_id.in_([snatched_status.get('id'), done_status.get('id')])) \
.all()
for rel in rels:
rel.status_id = ignored_status.get('id')
db.commit()
movie_dict = fireEvent('media.get', media_id=media_id, single=True)
log.info('Trying next release for: %s',
getTitle(movie_dict['library']))
fireEvent('movie.searcher.single', movie_dict, manual=manual)
return True
except:
log.error('Failed searching for next release: %s',
traceback.format_exc())
db.rollback()
return False
finally:
db.close()
def updateReleaseDate(self, identifier):
try:
db = get_session()
library = db.query(Library).filter_by(
identifier=identifier).first()
if not library.info:
library_dict = self.update(identifier)
dates = library_dict.get('info', {}).get('release_date')
else:
dates = library.info.get('release_date')
if dates and (dates.get('expires', 0) < time.time()
or dates.get('expires', 0) > time.time() +
(604800 * 4)) or not dates:
dates = fireEvent('movie.release_date',
identifier=identifier,
merge=True)
library.info.update({'release_date': dates})
db.commit()
return dates
except:
log.error('Failed updating release dates: %s',
traceback.format_exc())
db.rollback()
finally:
db.close()
return {}
def availableChars(self, status = ['active']):
chars = ''
db = get_session()
# Make a list from string
if not isinstance(status, (list, tuple)):
status = [status]
q = db.query(Movie) \
.join(Movie.library, Library.titles) \
.options(joinedload_all('library.titles')) \
.filter(LibraryTitle.default == True) \
.filter(or_(*[Movie.status.has(identifier = s) for s in status])) \
.group_by(Movie.id)
results = q.all()
for movie in results:
char = movie.library.titles[0].simple_title[0]
char = char if char in ascii_lowercase else '#'
if char not in chars:
chars += char
return chars
def updateSuggestionCache(self, ignore_imdb=None, limit=6, ignored=None):
# Combine with previous suggestion_cache
cached_suggestion = self.getCache('suggestion_cached')
new_suggestions = []
ignored = [] if not ignored else ignored
if ignore_imdb:
for cs in cached_suggestion:
if cs.get('imdb') != ignore_imdb:
new_suggestions.append(cs)
# Get new results and add them
if len(new_suggestions) - 1 < limit:
db = get_session()
active_movies = db.query(Movie) \
.filter(or_(*[Movie.status.has(identifier = s) for s in ['active', 'done']])).all()
movies = [x.library.identifier for x in active_movies]
ignored.extend([x.get('imdb') for x in cached_suggestion])
suggestions = fireEvent('movie.suggest',
movies=movies,
ignore=list(set(ignored)),
single=True)
if suggestions:
new_suggestions.extend(suggestions)
self.setCache(md5(ss('suggestion_cached')),
new_suggestions,
timeout=6048000)
return new_suggestions
def suggestView(self, **kwargs):
movies = splitString(kwargs.get('movies', ''))
ignored = splitString(kwargs.get('ignored', ''))
limit = kwargs.get('limit', 6)
if not movies or len(movies) == 0:
db = get_session()
active_movies = db.query(Movie) \
.filter(or_(*[Movie.status.has(identifier = s) for s in ['active', 'done']])).all()
movies = [x.library.identifier for x in active_movies]
if not ignored or len(ignored) == 0:
ignored = splitString(Env.prop('suggest_ignore', default=''))
cached_suggestion = self.getCache('suggestion_cached')
if cached_suggestion:
suggestions = cached_suggestion
else:
suggestions = fireEvent('movie.suggest',
movies=movies,
ignore=ignored,
single=True)
self.setCache(md5(ss('suggestion_cached')),
suggestions,
timeout=6048000) # Cache for 10 weeks
return {
'success': True,
'count': len(suggestions),
'suggestions': suggestions[:limit]
}
def all_movies(self):
if self.in_progress:
log.info("Search already in progress")
return
self.in_progress = True
db = get_session()
movies = db.query(Movie).filter(Movie.status.has(identifier="active")).all()
for movie in movies:
movie_dict = movie.to_dict(
{
"profile": {"types": {"quality": {}}},
"releases": {"status": {}, "quality": {}},
"library": {"titles": {}, "files": {}},
"files": {},
}
)
try:
self.single(movie_dict)
except IndexError:
fireEvent("library.update", movie_dict["library"]["identifier"], force=True)
except:
log.error("Search failed for %s: %s" % (movie_dict["library"]["identifier"], traceback.format_exc()))
# Break if CP wants to shut down
if self.shuttingDown():
break
# db.close()
self.in_progress = False
def getLibraryTags(self, imdb):
temp = {
'in_wanted': False,
'in_library': False,
}
# Add release info from current library
db = get_session()
try:
l = db.query(Library).filter_by(identifier = imdb).first()
if l:
# Statuses
active_status, done_status = fireEvent('status.get', ['active', 'done'], single = True)
for movie in l.movies:
if movie.status_id == active_status['id']:
temp['in_wanted'] = fireEvent('movie.get', movie.id, single = True)
for release in movie.releases:
if release.status_id == done_status['id']:
temp['in_library'] = fireEvent('movie.get', movie.id, single = True)
except:
log.error('Tried getting more info on searched movies: %s', traceback.format_exc())
return temp
def add(self,
path='',
part=1,
type_tuple=(),
available=1,
properties=None):
if not properties: properties = {}
type_id = self.getType(type_tuple).get('id')
db = get_session()
f = db.query(File).filter(File.path == toUnicode(path)).first()
if not f:
f = File()
db.add(f)
f.path = toUnicode(path)
f.part = part
f.available = available
f.type_id = type_id
db.commit()
file_dict = f.to_dict()
return file_dict
def searchLibrary(self):
# Get all active and online movies
db = get_session()
library = db.query(Library).all()
done_status = fireEvent('status.get', 'done', single=True)
for movie in library.movies:
for release in movie.releases:
# get releases and their movie files
if release.status_id is done_status.get('id'):
files = []
for file in release.files.filter(
FileType.status.has(identifier='movie')).all():
files.append(file.path)
# get subtitles for those files
subliminal.list_subtitles(files,
cache_dir=Env.get('cache_dir'),
multi=True,
languages=self.getLanguages(),
services=self.services)
def searchLibrary(self):
# Get all active and online movies
db = get_session()
library = db.query(Library).all()
done_status = fireEvent('status.get', 'done', single=True)
for movie in library.movies:
for release in movie.releases:
# get releases and their movie files
if release.status_id is done_status.get('id'):
files = []
for file in release.files.filter(
FileType.status.has(identifier='movie')).all():
files.append(file.path)
# get subtitles for those files
subliminal.list_subtitles(
files,
cache_dir=Env.get('cache_dir'),
multi=True,
languages=self.getLanguages(),
services=self.services)
def getLibraryTags(self, imdb):
temp = {
'in_wanted': False,
'in_library': False,
}
# Add release info from current library
db = get_session()
try:
l = db.query(Library).filter_by(identifier=imdb).first()
if l:
# Statuses
active_status, done_status = fireEvent('status.get',
['active', 'done'],
single=True)
for movie in l.movies:
if movie.status_id == active_status['id']:
temp['in_wanted'] = fireEvent('movie.get',
movie.id,
single=True)
for release in movie.releases:
if release.status_id == done_status['id']:
temp['in_library'] = fireEvent('movie.get',
movie.id,
single=True)
except:
log.error('Tried getting more info on searched movies: %s',
traceback.format_exc())
return temp
def cleanReleases(self):
prop_name = 'cleaned_releases'
already_cleaned = Env.prop(prop_name, default=False)
if already_cleaned:
return True
log.info('Removing releases from library movies')
db = get_session()
movies = db.query(Movie).all()
done_status = fireEvent('status.get', 'done', single=True)
available_status = fireEvent('status.get', 'available', single=True)
snatched_status = fireEvent('status.get', 'snatched', single=True)
for movie in movies:
if movie.status_id == done_status.get('id'):
for rel in movie.releases:
if rel.status_id in [
available_status.get('id'),
snatched_status.get('id')
]:
fireEvent('release.delete', id=rel.id, single=True)
Env.prop(prop_name, True)
def add(self, attrs={}, update_after=True):
db = get_session()
l = db.query(Library).filter_by(
identifier=attrs.get('identifier')).first()
if not l:
status = fireEvent('status.get', 'needs_update', single=True)
l = Library(year=attrs.get('year'),
identifier=attrs.get('identifier'),
plot=toUnicode(attrs.get('plot')),
tagline=toUnicode(attrs.get('tagline')),
status_id=status.get('id'))
title = LibraryTitle(title=toUnicode(attrs.get('title')),
simple_title=self.simplifyTitle(
attrs.get('title')))
l.titles.append(title)
db.add(l)
db.commit()
# Update library info
if update_after is not False:
handle = fireEventAsync if update_after is 'async' else fireEvent
handle('library.update',
identifier=l.identifier,
default_title=toUnicode(attrs.get('title', '')))
library_dict = l.to_dict(self.default_dict)
return library_dict
def refresh(self):
db = get_session()
for id in splitString(getParam('id')):
movie = db.query(Movie).filter_by(id=id).first()
if movie:
# Get current selected title
default_title = ''
for title in movie.library.titles:
if title.default: default_title = title.title
fireEvent('notify.frontend',
type='movie.busy.%s' % id,
data=True,
message='Updating "%s"' % default_title)
fireEventAsync('library.update',
identifier=movie.library.identifier,
default_title=default_title,
force=True,
on_complete=self.createOnComplete(id))
#db.close()
return jsonified({
'success': True,
})
def cleanDone(self):
log.debug('Removing releases from dashboard')
now = time.time()
week = 262080
done_status, available_status, snatched_status, downloaded_status, ignored_status = \
fireEvent('status.get', ['done', 'available', 'snatched', 'downloaded', 'ignored'], single = True)
db = get_session()
# get movies last_edit more than a week ago
media = db.query(Media) \
.filter(Media.status_id == done_status.get('id'), Media.last_edit < (now - week)) \
.all()
for item in media:
for rel in item.releases:
# Remove all available releases
if rel.status_id in [available_status.get('id')]:
fireEvent('release.delete', id=rel.id, single=True)
# Set all snatched and downloaded releases to ignored to make sure they are ignored when re-adding the move
elif rel.status_id in [
snatched_status.get('id'),
downloaded_status.get('id')
]:
self.updateStatus(id=rel.id, status=ignored_status)
db.expire_all()
def onComplete():
db = get_session()
media = db.query(Media).filter_by(id=id).first()
fireEventAsync('%s.searcher.single' % media.type,
media.to_dict(self.default_dict),
on_complete=self.createNotifyFront(id))
db.expire_all()
def tryNextRelease(self, movie_id, manual=False):
snatched_status = fireEvent('status.get', 'snatched', single=True)
ignored_status = fireEvent('status.get', 'ignored', single=True)
try:
db = get_session()
rels = db.query(Release).filter_by(
status_id=snatched_status.get('id'), movie_id=movie_id).all()
for rel in rels:
rel.status_id = ignored_status.get('id')
db.commit()
movie_dict = fireEvent('movie.get', movie_id, single=True)
log.info('Trying next release for: %s',
getTitle(movie_dict['library']))
fireEvent('searcher.single', movie_dict)
return True
except:
log.error('Failed searching for next release: %s',
traceback.format_exc())
return False
def notifyFront():
db = get_session()
media = db.query(Media).filter_by(id=media_id).first()
fireEvent('notify.frontend',
type='%s.update.%s' % (media.type, media.id),
data=media.to_dict(self.default_dict))
db.expire_all()
def getById(self, id):
db = get_session()
status = db.query(Status).filter_by(id=id).first()
status_dict = status.to_dict()
# db.close()
return status_dict
def scanFolderToLibrary(self, folder = None, newer_as = None):
if not os.path.isdir(folder):
return
groups = self.scan(folder = folder)
# Open up the db
db = get_session()
# Mark all files as "offline" before a adding them to the database (again)
files_in_path = db.query(File).filter(File.path.like(toUnicode(folder) + u'%%'))
files_in_path.update({'available': 0}, synchronize_session = False)
db.commit()
while True and not self.shuttingDown():
try:
identifier, group = groups.popitem()
except:
break
# Save to DB
if group['library']:
# Add release
fireEvent('release.add', group = group)
fireEvent('library.update', identifier = group['library'].get('identifier'))
db.remove()
def get(self, identifiers):
if not isinstance(identifiers, (list)):
identifiers = [identifiers]
db = get_session()
return_list = []
for identifier in identifiers:
if self.status_cached.get(identifier):
return_list.append(self.status_cached.get(identifier))
continue
s = db.query(Status).filter_by(identifier = identifier).first()
if not s:
s = Status(
identifier = identifier,
label = toUnicode(identifier.capitalize())
)
db.add(s)
db.commit()
status_dict = s.to_dict()
self.status_cached[identifier] = status_dict
return_list.append(status_dict)
return return_list if len(identifiers) > 1 else return_list[0]
def save(self, **kwargs):
db = get_session()
p = db.query(Profile).filter_by(id=kwargs.get('id')).first()
if not p:
p = Profile()
db.add(p)
p.label = toUnicode(kwargs.get('label'))
p.order = kwargs.get('order', p.order if p.order else 0)
p.core = kwargs.get('core', False)
#delete old types
[db.delete(t) for t in p.types]
order = 0
for type in kwargs.get('types', []):
t = ProfileType(order=order,
finish=type.get('finish') if order > 0 else 1,
wait_for=kwargs.get('wait_for'),
quality_id=type.get('quality_id'))
p.types.append(t)
order += 1
db.commit()
profile_dict = p.to_dict(self.to_dict)
return {'success': True, 'profile': profile_dict}
def listView(self):
db = get_session()
limit_offset = getParam('limit_offset', None)
q = db.query(Notif)
if limit_offset:
splt = [x.strip() for x in limit_offset.split(',')]
limit = splt[0]
offset = 0 if len(splt) is 1 else splt[1]
q = q.limit(limit).offset(offset)
results = q.all()
notifications = []
for n in results:
ndict = n.to_dict()
ndict['type'] = 'notification'
notifications.append(ndict)
#db.close()
return jsonified({
'success': True,
'empty': len(notifications) == 0,
'notifications': notifications
})
def default(self):
db = get_session()
default = db.query(Profile).first()
default_dict = default.to_dict(self.to_dict)
return default_dict
def updateLibrary(self, full = False):
if self.isDisabled() or (self.last_update > time.time() - 20):
return
directories = self.directories()
for directory in directories:
if not os.path.isdir(directory):
if len(directory) > 0:
log.error('Directory doesn\'t exist: %s' % directory)
continue
log.info('Updating manage library: %s' % directory)
fireEvent('scanner.folder', folder = directory)
# If cleanup option is enabled, remove offline files from database
if self.conf('cleanup'):
db = get_session()
files_in_path = db.query(File).filter(File.path.like(directory + '%%')).filter_by(available = 0).all()
[db.delete(x) for x in files_in_path]
db.commit()
db.remove()
# Break if CP wants to shut down
if self.shuttingDown():
break
self.last_update = time.time()
def add(self, attrs = {}):
db = get_session()
l = db.query(Library).filter_by(identifier = attrs.get('identifier')).first()
if not l:
l = Library(
year = attrs.get('year'),
identifier = attrs.get('identifier'),
plot = attrs.get('plot'),
tagline = attrs.get('tagline')
)
title = LibraryTitle(
title = attrs.get('title')
)
l.titles.append(title)
db.add(l)
db.commit()
# Update library info
fireEventAsync('library.update', library = l, default_title = attrs.get('title', ''))
#db.remove()
return l
def add(self, attrs = {}, update_after = True):
db = get_session()
l = db.query(Library).filter_by(identifier = attrs.get('identifier')).first()
if not l:
status = fireEvent('status.get', 'needs_update', single = True)
l = Library(
year = attrs.get('year'),
identifier = attrs.get('identifier'),
plot = toUnicode(attrs.get('plot')),
tagline = toUnicode(attrs.get('tagline')),
status_id = status.get('id')
)
title = LibraryTitle(
title = toUnicode(attrs.get('title')),
simple_title = self.simplifyTitle(attrs.get('title')),
)
l.titles.append(title)
db.add(l)
db.commit()
# Update library info
if update_after is not False:
handle = fireEventAsync if update_after is 'async' else fireEvent
handle('library.update', identifier = l.identifier, default_title = toUnicode(attrs.get('title', '')))
library_dict = l.to_dict(self.default_dict)
return library_dict
def save(self, **kwargs):
db = get_session()
p = db.query(Profile).filter_by(id=kwargs.get("id")).first()
if not p:
p = Profile()
db.add(p)
p.label = toUnicode(kwargs.get("label"))
p.order = kwargs.get("order", p.order if p.order else 0)
p.core = kwargs.get("core", False)
# delete old types
[db.delete(t) for t in p.types]
order = 0
for type in kwargs.get("types", []):
t = ProfileType(
order=order,
finish=type.get("finish") if order > 0 else 1,
wait_for=kwargs.get("wait_for"),
quality_id=type.get("quality_id"),
)
p.types.append(t)
order += 1
db.commit()
profile_dict = p.to_dict(self.to_dict)
return {"success": True, "profile": profile_dict}
def add(self, attrs={}, update_after=True):
db = get_session()
l = db.query(Library).filter_by(identifier=attrs.get("identifier")).first()
if not l:
status = fireEvent("status.get", "needs_update", single=True)
l = Library(
year=attrs.get("year"),
identifier=attrs.get("identifier"),
plot=toUnicode(attrs.get("plot")),
tagline=toUnicode(attrs.get("tagline")),
status_id=status.get("id"),
)
title = LibraryTitle(
title=toUnicode(attrs.get("title")), simple_title=self.simplifyTitle(attrs.get("title"))
)
l.titles.append(title)
db.add(l)
db.commit()
# Update library info
if update_after is not False:
handle = fireEventAsync if update_after is "async" else fireEvent
handle("library.update", identifier=l.identifier, default_title=attrs.get("title", ""))
return l.to_dict(self.default_dict)
def listView(self, limit_offset = None, **kwargs):
db = get_session()
q = db.query(Notif)
if limit_offset:
splt = splitString(limit_offset)
limit = splt[0]
offset = 0 if len(splt) is 1 else splt[1]
q = q.limit(limit).offset(offset)
else:
q = q.limit(200)
results = q.all()
notifications = []
for n in results:
ndict = n.to_dict()
ndict['type'] = 'notification'
notifications.append(ndict)
return {
'success': True,
'empty': len(notifications) == 0,
'notifications': notifications
}
def suggestView(self, limit = 6, **kwargs):
movies = splitString(kwargs.get('movies', ''))
ignored = splitString(kwargs.get('ignored', ''))
seen = splitString(kwargs.get('seen', ''))
cached_suggestion = self.getCache('suggestion_cached')
if cached_suggestion:
suggestions = cached_suggestion
else:
if not movies or len(movies) == 0:
db = get_session()
active_movies = db.query(Movie) \
.options(joinedload_all('library')) \
.filter(or_(*[Movie.status.has(identifier = s) for s in ['active', 'done']])).all()
movies = [x.library.identifier for x in active_movies]
if not ignored or len(ignored) == 0:
ignored = splitString(Env.prop('suggest_ignore', default = ''))
if not seen or len(seen) == 0:
movies.extend(splitString(Env.prop('suggest_seen', default = '')))
suggestions = fireEvent('movie.suggest', movies = movies, ignore = ignored, single = True)
self.setCache('suggestion_cached', suggestions, timeout = 6048000) # Cache for 10 weeks
return {
'success': True,
'count': len(suggestions),
'suggestions': suggestions[:int(limit)]
}
def cleanReleases(self):
log.debug('Removing releases from dashboard')
now = time.time()
week = 262080
done_status, available_status, snatched_status = \
fireEvent('status.get', ['done', 'available', 'snatched'], single = True)
db = get_session()
# get movies last_edit more than a week ago
movies = db.query(Movie) \
.filter(Movie.status_id == done_status.get('id'), Movie.last_edit < (now - week)) \
.all()
for movie in movies:
for rel in movie.releases:
if rel.status_id in [
available_status.get('id'),
snatched_status.get('id')
]:
fireEvent('release.delete', id=rel.id, single=True)
db.expire_all()
def download(self):
db = get_session()
id = getParam('id')
rel = db.query(Relea).filter_by(id = id).first()
if rel:
item = {}
for info in rel.info:
item[info.identifier] = info.value
# Get matching provider
provider = fireEvent('provider.belongs_to', item['url'], single = True)
item['download'] = provider.download
fireEvent('searcher.download', data = item, movie = rel.movie.to_dict({
'profile': {'types': {'quality': {}}},
'releases': {'status': {}, 'quality': {}},
'library': {'titles': {}, 'files':{}},
'files': {}
}))
return jsonified({
'success': True
})
else:
log.error('Couldn\'t find release with id: %s' % id)
return jsonified({
'success': False
})
def refresh(self, id='', **kwargs):
db = get_session()
for x in splitString(id):
movie = db.query(Movie).filter_by(id=x).first()
if movie:
# Get current selected title
default_title = ''
for title in movie.library.titles:
if title.default: default_title = title.title
fireEvent('notify.frontend',
type='movie.busy.%s' % x,
data=True)
fireEventAsync('library.update',
identifier=movie.library.identifier,
default_title=default_title,
force=True,
on_complete=self.createOnComplete(x))
db.expire_all()
return {
'success': True,
}
def extendDownloadInfo(self, download_info):
rls = None
if download_info and download_info.get('id') and download_info.get('downloader'):
db = get_session()
rlsnfo_dwnlds = db.query(ReleaseInfo).filter_by(identifier = 'download_downloader', value = download_info.get('downloader')).all()
rlsnfo_ids = db.query(ReleaseInfo).filter_by(identifier = 'download_id', value = download_info.get('id')).all()
for rlsnfo_dwnld in rlsnfo_dwnlds:
for rlsnfo_id in rlsnfo_ids:
if rlsnfo_id.release == rlsnfo_dwnld.release:
rls = rlsnfo_id.release
break
if rls: break
if not rls:
log.error('Download ID %s from downloader %s not found in releases', (download_info.get('id'), download_info.get('downloader')))
if rls:
rls_dict = rls.to_dict({'info':{}})
download_info.update({
'imdb_id': rls.movie.library.identifier,
'quality': rls.quality.identifier,
'type': rls_dict.get('info', {}).get('type')
})
return download_info
def restatus(self, movie_id):
active_status, done_status = fireEvent('status.get',
['active', 'done'],
single=True)
db = get_session()
m = db.query(Movie).filter_by(id=movie_id).first()
if not m or len(m.library.titles) == 0:
log.debug('Can\'t restatus movie, doesn\'t seem to exist.')
return False
log.debug('Changing status for %s', (m.library.titles[0].title))
if not m.profile:
m.status_id = done_status.get('id')
else:
move_to_wanted = True
for t in m.profile.types:
for release in m.releases:
if t.quality.identifier is release.quality.identifier and (
release.status_id is done_status.get('id')
and t.finish):
move_to_wanted = False
m.status_id = active_status.get(
'id') if move_to_wanted else done_status.get('id')
db.commit()
return True
def updateStatus(self, id, status=None):
if not status: return False
db = get_session()
rel = db.query(Relea).filter_by(id=id).first()
if rel and status and rel.status_id != status.get('id'):
item = {}
for info in rel.info:
item[info.identifier] = info.value
if rel.files:
for file_item in rel.files:
if file_item.type.identifier == 'movie':
release_name = os.path.basename(file_item.path)
break
else:
release_name = item['name']
#update status in Db
log.debug('Marking release %s as %s',
(release_name, status.get("label")))
rel.status_id = status.get('id')
rel.last_edit = int(time.time())
db.commit()
#Update all movie info as there is no release update function
fireEvent('notify.frontend',
type='release.update_status',
data=rel.to_dict())
return True
def onComplete():
db = get_session()
movie = db.query(Movie).filter_by(id=movie_id).first()
fireEventAsync('searcher.single',
movie.to_dict(self.default_dict),
on_complete=self.createNotifyFront(movie_id))
db.expire_all()
def listView(self, limit_offset=None, **kwargs):
db = get_session()
q = db.query(Notif)
if limit_offset:
splt = splitString(limit_offset)
limit = splt[0]
offset = 0 if len(splt) is 1 else splt[1]
q = q.limit(limit).offset(offset)
else:
q = q.limit(200)
results = q.all()
notifications = []
for n in results:
ndict = n.to_dict()
ndict['type'] = 'notification'
notifications.append(ndict)
return {
'success': True,
'empty': len(notifications) == 0,
'notifications': notifications
}
def notifyFront():
db = get_session()
movie = db.query(Movie).filter_by(id=movie_id).first()
fireEvent('notify.frontend',
type='movie.update.%s' % movie.id,
data=movie.to_dict(self.default_dict))
db.expire_all()
def notifyFront():
db = get_session()
show = db.query(Media).filter_by(id=show_id).first()
fireEvent('notify.frontend',
type='show.update.%s' % show.id,
data=show.to_dict(self.default_dict))
db.expire_all()
def fill(self):
db = get_session()
profiles = [
{"label": "Best", "qualities": ["720p", "1080p", "brrip", "dvdrip"]},
{"label": "HD", "qualities": ["720p", "1080p"]},
{"label": "SD", "qualities": ["dvdrip", "dvdr"]},
]
# Create default quality profile
order = -2
for profile in profiles:
log.info("Creating default profile: %s" % profile.get("label"))
p = Profile(label=toUnicode(profile.get("label")), order=order)
db.add(p)
quality_order = 0
for quality in profile.get("qualities"):
quality = fireEvent("quality.single", identifier=quality, single=True)
profile_type = ProfileType(
quality_id=quality.get("id"), profile=p, finish=True, wait_for=0, order=quality_order
)
p.types.append(profile_type)
db.commit()
quality_order += 1
order += 1
db.close()
return True
def availableChars(self, status = None, release_status = None):
chars = ''
db = get_session()
# Make a list from string
if not isinstance(status, (list, tuple)):
status = [status]
if release_status and not isinstance(release_status, (list, tuple)):
release_status = [release_status]
q = db.query(Movie) \
.outerjoin(Movie.releases, Movie.library, Library.titles, Movie.status) \
.options(joinedload_all('library.titles'))
# Filter on movie status
if status and len(status) > 0:
q = q.filter(or_(*[Movie.status.has(identifier = s) for s in status]))
# Filter on release status
if release_status and len(release_status) > 0:
q = q.filter(or_(*[Release.status.has(identifier = s) for s in release_status]))
results = q.all()
for movie in results:
char = movie.library.titles[0].simple_title[0]
char = char if char in ascii_lowercase else '#'
if char not in chars:
chars += str(char)
db.expire_all()
return ''.join(sorted(chars, key = str.lower))
def tryNextRelease(self, movie_id, manual = False):
snatched_status = fireEvent('status.get', 'snatched', single = True)
ignored_status = fireEvent('status.get', 'ignored', single = True)
try:
db = get_session()
rels = db.query(Release).filter_by(
status_id = snatched_status.get('id'),
movie_id = movie_id
).all()
for rel in rels:
rel.status_id = ignored_status.get('id')
db.commit()
movie_dict = fireEvent('movie.get', movie_id, single = True)
log.info('Trying next release for: %s', getTitle(movie_dict['library']))
fireEvent('searcher.single', movie_dict)
return True
except:
log.error('Failed searching for next release: %s', traceback.format_exc())
return False
def all_movies(self):
if self.in_progress:
log.info('Search already in progress')
return
self.in_progress = True
db = get_session()
movies = db.query(Movie).filter(
Movie.status.has(identifier = 'active')
).all()
for movie in movies:
movie_dict = movie.to_dict({
'profile': {'types': {'quality': {}}},
'releases': {'status': {}, 'quality': {}},
'library': {'titles': {}, 'files':{}},
'files': {}
})
try:
self.single(movie_dict)
except IndexError:
fireEvent('library.update', movie_dict['library']['identifier'], force = True)
except:
log.error('Search failed for %s: %s', (movie_dict['library']['identifier'], traceback.format_exc()))
# Break if CP wants to shut down
if self.shuttingDown():
break
#db.close()
self.in_progress = False
def updateStatus(self, id, status = None):
if not status: return False
db = get_session()
rel = db.query(Relea).filter_by(id = id).first()
if rel and status and rel.status_id != status.get('id'):
item = {}
for info in rel.info:
item[info.identifier] = info.value
if rel.files:
for file_item in rel.files:
if file_item.type.identifier == 'movie':
release_name = os.path.basename(file_item.path)
break
else:
release_name = item['name']
#update status in Db
log.debug('Marking release %s as %s', (release_name, status.get("label")))
rel.status_id = status.get('id')
rel.last_edit = int(time.time())
db.commit()
#Update all movie info as there is no release update function
fireEvent('notify.frontend', type = 'release.update_status.%s' % rel.id, data = status.get('id'))
return True
def get(self, identifiers):
if not isinstance(identifiers, (list)):
identifiers = [identifiers]
db = get_session()
return_list = []
for identifier in identifiers:
if self.status_cached.get(identifier):
return_list.append(self.status_cached.get(identifier))
continue
s = db.query(Status).filter_by(identifier=identifier).first()
if not s:
s = Status(identifier=identifier, label=toUnicode(identifier.capitalize()))
db.add(s)
db.commit()
status_dict = s.to_dict()
self.status_cached[identifier] = status_dict
return_list.append(status_dict)
return return_list if len(identifiers) > 1 else return_list[0]
def cleanDone(self):
log.debug('Removing releases from dashboard')
now = time.time()
week = 262080
done_status, available_status, snatched_status, downloaded_status, ignored_status = \
fireEvent('status.get', ['done', 'available', 'snatched', 'downloaded', 'ignored'], single = True)
db = get_session()
# get movies last_edit more than a week ago
media = db.query(Media) \
.filter(Media.status_id == done_status.get('id'), Media.last_edit < (now - week)) \
.all()
for item in media:
for rel in item.releases:
# Remove all available releases
if rel.status_id in [available_status.get('id')]:
fireEvent('release.delete', id = rel.id, single = True)
# Set all snatched and downloaded releases to ignored to make sure they are ignored when re-adding the move
elif rel.status_id in [snatched_status.get('id'), downloaded_status.get('id')]:
self.updateStatus(id = rel.id, status = ignored_status)
db.expire_all()
def getById(self, id):
db = get_session()
status = db.query(Status).filter_by(id = id).first()
status_dict = status.to_dict()
#db.close()
return status_dict
def listener(self):
messages = []
for message in self.messages:
#delete message older then 15s
if message['time'] > (time.time() - 15):
messages.append(message)
# Get unread
if getParam('init'):
db = get_session()
notifications = db.query(Notif) \
.filter(or_(Notif.read == False, Notif.added > (time.time() - 259200))) \
.all()
for n in notifications:
ndict = n.to_dict()
ndict['type'] = 'notification'
messages.append(ndict)
#db.close()
self.messages = []
return jsonified({
'success': True,
'result': messages,
})
def save(self):
params = getParams()
db = get_session()
p = db.query(Profile).filter_by(id=params.get("id")).first()
if not p:
p = Profile()
db.add(p)
p.label = params.get("label")
p.order = params.get("order", p.order if p.order else 0)
p.core = params.get("core", False)
# delete old types
[db.delete(t) for t in p.types]
order = 0
for type in params.get("types", []):
t = ProfileType(
order=order,
finish=type.get("finish"),
wait_for=params.get("wait_for"),
quality_id=type.get("quality_id"),
)
p.types.append(t)
order += 1
db.commit()
return jsonified({"success": True, "profile": p.to_dict(deep={"types": {}})})
def notifyFront():
db = get_session()
movie = db.query(Movie).filter_by(id=movie_id).first()
fireEvent(
'notify.frontend',
type='movie.update.%s' % movie.id,
data=movie.to_dict(self.default_dict))
