def list(self):
params = getParams()
db = get_session()
results = db.query(Movie).filter(
Movie.status.has(identifier=params.get('status', 'active'))).all()
movies = []
for movie in results:
temp = movie.to_dict(
deep={
'releases': {
'status': {},
'quality': {}
},
'library': {
'titles': {},
'files': {}
},
'files': {}
})
movies.append(temp)
return jsonified({
'success': True,
'empty': len(movies) == 0,
'movies': movies,
})
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 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 = toUnicode(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') if order > 0 else 1,
wait_for=params.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)
#db.close()
return jsonified({'success': True, 'profile': profile_dict})
def get(self, route, *args, **kwargs):
route = route.strip('/')
if not api.get(route):
self.write('API call doesn\'t seem to exist')
return
api_locks[route].acquire()
try:
kwargs = {}
for x in self.request.arguments:
kwargs[x] = urllib.unquote(self.get_argument(x))
# Split array arguments
kwargs = getParams(kwargs)
kwargs['_request'] = self
# Remove t random string
try: del kwargs['t']
except: pass
# Add async callback handler
run_handler(route, kwargs, callback = self.taskFinished)
except:
log.error('Failed doing api request "%s": %s', (route, traceback.format_exc()))
try:
self.write({'success': False, 'error': 'Failed returning results'})
self.finish()
except:
log.error('Failed write error "%s": %s', (route, traceback.format_exc()))
api_locks[route].release()
def addView(self):
params = getParams()
movie_dict = self.add(params)
return jsonified({"success": True, "added": True if movie_dict else False, "movie": movie_dict})
def charView(self):
params = getParams()
status = params.get("status", ["active"])
chars = self.availableChars(status)
return jsonified({"success": True, "empty": len(chars) == 0, "chars": chars})
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 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 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 listView(self):
params = getParams()
status = splitString(params.get('status', None))
release_status = splitString(params.get('release_status', None))
limit_offset = params.get('limit_offset', None)
starts_with = params.get('starts_with', None)
search = params.get('search', None)
order = params.get('order', None)
total_movies, movies = self.list(
status = status,
release_status = release_status,
limit_offset = limit_offset,
starts_with = starts_with,
search = search,
order = order
)
return jsonified({
'success': True,
'empty': len(movies) == 0,
'total': total_movies,
'movies': movies,
})
def get(self, route, *args, **kwargs):
route = route.strip('/')
if not api.get(route):
self.write('API call doesn\'t seem to exist')
return
kwargs = {}
for x in self.request.arguments:
kwargs[x] = urllib.unquote(self.get_argument(x))
# Split array arguments
kwargs = getParams(kwargs)
# Remove t random string
try: del kwargs['t']
except: pass
# Check JSONP callback
result = api[route](**kwargs)
jsonp_callback = self.get_argument('callback_func', default = None)
if jsonp_callback:
self.write(str(jsonp_callback) + '(' + json.dumps(result) + ')')
elif isinstance(result, (tuple)) and result[0] == 'redirect':
self.redirect(result[1])
else:
self.write(result)
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 get(self, route, *args, **kwargs):
route = route.strip('/')
if not api.get(route):
self.write('API call doesn\'t seem to exist')
return
kwargs = {}
for x in self.request.arguments:
kwargs[x] = urllib.unquote(self.get_argument(x))
# Split array arguments
kwargs = getParams(kwargs)
# Remove t random string
try:
del kwargs['t']
except:
pass
# Check JSONP callback
result = api[route](**kwargs)
jsonp_callback = self.get_argument('callback_func', default=None)
if jsonp_callback:
self.write(str(jsonp_callback) + '(' + json.dumps(result) + ')')
elif isinstance(result, (tuple)) and result[0] == 'redirect':
self.redirect(result[1])
else:
self.write(result)
def charView(self):
params = getParams()
status = splitString(params.get("status", None))
release_status = splitString(params.get("release_status", None))
chars = self.availableChars(status, release_status)
return jsonified({"success": True, "empty": len(chars) == 0, "chars": chars})
def get(self, route, *args, **kwargs):
route = route.strip('/')
if not api.get(route):
self.write('API call doesn\'t seem to exist')
return
api_locks[route].acquire()
try:
kwargs = {}
for x in self.request.arguments:
kwargs[x] = urllib.unquote(self.get_argument(x))
# Split array arguments
kwargs = getParams(kwargs)
kwargs['_request'] = self
# Remove t random string
try:
del kwargs['t']
except:
pass
# Add async callback handler
@run_async
def run_handler(callback):
try:
res = api[route](**kwargs)
callback(res)
except:
log.error('Failed doing api request "%s": %s',
(route, traceback.format_exc()))
callback({
'success': False,
'error': 'Failed returning results'
})
result = yield tornado.gen.Task(run_handler)
# Check JSONP callback
jsonp_callback = self.get_argument('callback_func', default=None)
if jsonp_callback:
self.write(
str(jsonp_callback) + '(' + json.dumps(result) + ')')
self.set_header("Content-Type", "text/javascript")
elif isinstance(result, tuple) and result[0] == 'redirect':
self.redirect(result[1])
else:
self.write(result)
except:
log.error('Failed doing api request "%s": %s',
(route, traceback.format_exc()))
self.write({'success': False, 'error': 'Failed returning results'})
api_locks[route].release()
def deleteView(self):
params = getParams()
ids = [x.strip() for x in params.get("id").split(",")]
for movie_id in ids:
self.delete(movie_id, delete_from=params.get("delete_from", "all"))
return jsonified({"success": True})
def deleteView(self):
params = getParams()
ids = splitString(params.get("id"))
for movie_id in ids:
self.delete(movie_id, delete_from=params.get("delete_from", "all"))
return jsonified({"success": True})
def updateLibraryView(self):
params = getParams()
fireEventAsync('manage.update', full = params.get('full', True))
return jsonified({
'success': True
})
def deleteView(self):
params = getParams()
ids = splitString(params.get('id'))
for movie_id in ids:
self.delete(movie_id, delete_from = params.get('delete_from', 'all'))
return jsonified({
'success': True,
})
def statusView(self):
params = getParams()
ids = [x.strip() for x in params.get('id').split(',')]
for movie_id in ids:
self.status(movie_id, status = params.get('status', 'done'))
return jsonified({
'success': True,
})
def deleteView(self):
params = getParams()
ids = [x.strip() for x in params.get('id').split(',')]
for movie_id in ids:
self.delete(movie_id, delete_from = params.get('delete_from', 'all'))
return jsonified({
'success': True,
})
def autoConfig(self):
params = getParams()
host = params.get('host', 'localhost')
database = ''
mount = ''
try:
terminal = telnetlib.Telnet(host)
except Exception:
log.error('Warning: unable to get a telnet session to %s' % (host))
return self.failed()
log.debug('Connected to %s via telnet' % (host))
terminal.read_until('sh-3.00# ')
terminal.write('cat /tmp/source\n')
terminal.write('cat /tmp/netshare\n')
terminal.write('exit\n')
tnoutput = terminal.read_all()
match = re.search(r'(.+\.db)\r\n?(.+)(?=sh-3.00# cat /tmp/netshare)',
tnoutput)
if match:
database = match.group(1)
device = match.group(2)
log.info('Found NMJ database %s on device %s' % (database, device))
else:
log.error(
'Could not get current NMJ database on %s, NMJ is probably not running!'
% (host))
return self.failed()
if device.startswith('NETWORK_SHARE/'):
match = re.search('.*(?=\r\n?%s)' % (re.escape(device[14:])),
tnoutput)
if match:
mount = match.group().replace('127.0.0.1', host)
log.info(
'Found mounting url on the Popcorn Hour in configuration: %s'
% (mount))
else:
log.error(
'Detected a network share on the Popcorn Hour, but could not get the mounting url'
)
return self.failed()
return jsonified({
'success': True,
'database': database,
'mount': mount,
})
def listView(self):
params = getParams()
status = params.get("status", ["active"])
limit_offset = params.get("limit_offset", None)
starts_with = params.get("starts_with", None)
search = params.get("search", None)
movies = self.list(status=status, limit_offset=limit_offset, starts_with=starts_with, search=search)
return jsonified({"success": True, "empty": len(movies) == 0, "movies": movies})
def charView(self):
params = getParams()
status = params.get('status', ['active'])
chars = self.availableChars(status)
return jsonified({
'success': True,
'empty': len(chars) == 0,
'chars': chars,
})
def deleteView(self):
params = getParams()
ids = [x.strip() for x in params.get('id').split(',')]
for movie_id in ids:
self.delete(movie_id, delete_from = params.get('delete_from', 'all'))
return jsonified({
'success': True,
})
def deleteView(self):
params = getParams()
ids = splitString(params.get('id'))
for movie_id in ids:
self.delete(movie_id, delete_from=params.get('delete_from', 'all'))
return jsonified({
'success': True,
})
def addView(self):
params = getParams()
movie_dict = self.add(params)
return jsonified({
'success': True,
'added': True if movie_dict else False,
'movie': movie_dict,
})
def deleteView(self):
params = getParams()
ids = params.get('id').split(',')
for movie_id in ids:
self.delete(movie_id)
return jsonified({
'success': True,
})
def charView(self):
params = getParams()
status = params.get('status', ['active'])
chars = self.availableChars(status)
return jsonified({
'success': True,
'empty': len(chars) == 0,
'chars': chars,
})
def addView(self):
params = getParams()
movie_dict = self.add(params)
return jsonified({
'success': True,
'added': True if movie_dict else False,
'movie': movie_dict,
})
def search(self):
params = getParams()
cache_key = "%s/%s" % (__name__, urlencode(params))
movies = Env.get("cache").get(cache_key)
if not movies:
movies = fireEvent("movie.search", q=params.get("q"), merge=True)
Env.get("cache").set(cache_key, movies)
return jsonified({"success": True, "empty": len(movies) == 0 if movies else 0, "movies": movies})
def charView(self):
params = getParams()
status = splitString(params.get('status', None))
release_status = splitString(params.get('release_status', None))
chars = self.availableChars(status, release_status)
return jsonified({
'success': True,
'empty': len(chars) == 0,
'chars': chars,
})
def charView(self):
params = getParams()
status = splitString(params.get('status', None))
release_status = splitString(params.get('release_status', None))
chars = self.availableChars(status, release_status)
return jsonified({
'success': True,
'empty': len(chars) == 0,
'chars': chars,
})
def saveSize(self):
params = getParams()
db = get_session()
quality = db.query(Quality).filter_by(identifier=params.get("identifier")).first()
if quality:
setattr(quality, params.get("value_type"), params.get("value"))
db.commit()
return jsonified({"success": True})
def getApiKey():
api = None
params = getParams()
username = Env.setting('username')
password = Env.setting('password')
if (params.get('u') == md5(username)
or not username) and (params.get('p') == password or not password):
api = Env.setting('api_key')
return jsonified({'success': api is not None, 'api_key': api})
def saveView(self):
params = getParams()
section = params.get("section")
option = params.get("name")
value = params.get("value")
self.set(section, option, value)
self.save()
return jsonified({"success": True})
def saveSize(self):
params = getParams()
db = get_session()
quality = db.query(Quality).filter_by(
identifier=params.get('identifier')).first()
if quality:
setattr(quality, params.get('value_type'), params.get('value'))
db.commit()
return jsonified({'success': True})
def get(self, route, *args, **kwargs):
route = route.strip("/")
if not api.get(route):
self.write("API call doesn't seem to exist")
return
api_locks[route].acquire()
try:
kwargs = {}
for x in self.request.arguments:
kwargs[x] = urllib.unquote(self.get_argument(x))
# Split array arguments
kwargs = getParams(kwargs)
# Remove t random string
try:
del kwargs["t"]
except:
pass
# Add async callback handler
@run_async
def run_handler(callback):
try:
result = api[route](**kwargs)
callback(result)
except:
log.error('Failed doing api request "%s": %s', (route, traceback.format_exc()))
callback({"success": False, "error": "Failed returning results"})
result = yield tornado.gen.Task(run_handler)
# Check JSONP callback
jsonp_callback = self.get_argument("callback_func", default=None)
if jsonp_callback:
self.write(str(jsonp_callback) + "(" + json.dumps(result) + ")")
self.set_header("Content-Type", "text/javascript")
elif isinstance(result, tuple) and result[0] == "redirect":
self.redirect(result[1])
else:
self.write(result)
except:
log.error('Failed doing api request "%s": %s', (route, traceback.format_exc()))
self.write({"success": False, "error": "Failed returning results"})
api_locks[route].release()
def saveView(self):
params = getParams()
section = params.get('section')
option = params.get('name')
value = params.get('value')
self.set(section, option, value)
self.save()
return jsonified({
'success': True,
})
def delete(self):
params = getParams()
db = get_session()
status = fireEvent("status.add", "deleted", single=True)
ids = params.get("id").split(",")
for movie_id in ids:
movie = db.query(Movie).filter_by(id=movie_id).first()
movie.status_id = status.get("id")
db.commit()
return jsonified({"success": True})
def delete(self):
params = getParams()
db = get_session()
status = fireEvent('status.add', 'deleted', single=True)
movie = db.query(Movie).filter_by(id=params.get('id')).first()
movie.status_id = status.id
db.commit()
return jsonified({
'success': True,
})
def log(self):
params = getParams()
try:
log_message = 'API log: %s' % params
try:
getattr(log, params.get('type', 'error'))(log_message)
except:
log.error(log_message)
except:
log.error('Couldn\'t log via API: %s', params)
return jsonified({'success': True})
def delete(self):
params = getParams()
db = get_session()
status = fireEvent('status.add', 'deleted', single = True)
movie = db.query(Movie).filter_by(id = params.get('id')).first()
movie.status_id = status.get('id')
db.commit()
return jsonified({
'success': True,
})
def getApiKey():
api = None
params = getParams()
username = Env.setting('username')
password = Env.setting('password')
if (params.get('u') == md5(username) or not username) and (params.get('p') == password or not password):
api = Env.setting('api_key')
return jsonified({
'success': api is not None,
'api_key': api
})
def saveView(self):
params = getParams()
section = params.get('section')
option = params.get('name')
value = params.get('value')
self.set(section, option, value)
self.save()
return jsonified({
'success': True,
})
def scanView(self):
params = getParams()
movie_folder = params.get('movie_folder', None)
downloader = params.get('downloader', None)
download_id = params.get('download_id', None)
fireEventAsync('renamer.scan',
movie_folder = movie_folder,
download_info = {'id': download_id, 'downloader': downloader} if download_id else None
)
return jsonified({
'success': True
})
def listView(self):
params = getParams()
status = params.get('status', ['active'])
limit_offset = params.get('limit_offset', None)
starts_with = params.get('starts_with', None)
search = params.get('search', None)
total_movies, movies = self.list(status = status, limit_offset = limit_offset, starts_with = starts_with, search = search)
return jsonified({
'success': True,
'empty': len(movies) == 0,
'total': total_movies,
'movies': movies,
})
def saveOrder(self):
params = getParams()
db = get_session()
order = 0
for profile in params.get('ids', []):
p = db.query(Profile).filter_by(id=profile).first()
p.hide = params.get('hidden')[order]
p.order = order
order += 1
db.commit()
return jsonified({'success': True})
def saveView(self):
params = getParams()
section = params.get('section')
option = params.get('name')
value = params.get('value')
# See if a value handler is attached, use that as value
new_value = fireEvent('setting.save.%s.%s' % (section, option), value, single = True)
self.set(section, option, (new_value if new_value else value).encode('unicode_escape'))
self.save()
return jsonified({
'success': True,
})
def get(self, route, *args, **kwargs):
self.route = route = route.strip('/')
if not api.get(route):
self.write('API call doesn\'t seem to exist')
self.finish()
return
# Create lock if it doesn't exist
if route in api_locks and not api_locks.get(route):
api_locks[route] = threading.Lock()
api_locks[route].acquire()
try:
kwargs = {}
for x in self.request.arguments:
kwargs[x] = urllib.unquote(self.get_argument(x))
# Split array arguments
kwargs = getParams(kwargs)
kwargs['_request'] = self
# Remove t random string
try:
del kwargs['t']
except:
pass
# Add async callback handler
run_handler(route, kwargs, callback=self.taskFinished)
except:
log.error('Failed doing api request "%s": %s',
(route, traceback.format_exc()))
try:
self.write({
'success': False,
'error': 'Failed returning results'
})
self.finish()
except:
log.error('Failed write error "%s": %s',
(route, traceback.format_exc()))
self.unlock()
def suggestView(self):
params = getParams()
movies = params.get('movies')
ignore = params.get('ignore', [])
if not movies:
db = get_session()
active_movies = db.query(Movie).filter(Movie.status.has(identifier = 'active')).all()
movies = [x.library.identifier for x in active_movies]
suggestions = self.suggest(movies, ignore)
return jsonified({
'success': True,
'count': len(suggestions),
'suggestions': suggestions
})
def edit(self):
params = getParams()
db = get_session()
m = db.query(Movie).filter_by(id=params.get('id')).first()
m.profile_id = params.get('profile_id')
# Default title
for title in m.library.titles:
title.default = params.get(
'default_title').lower() == title.title.lower()
db.commit()
return jsonified({
'success': True,
})
def scanView(self):
params = getParams()
async = tryInt(params.get('async', None))
movie_folder = params.get('movie_folder', None)
downloader = params.get('downloader', None)
download_id = params.get('download_id', None)
fire_handle = fireEvent if not async else fireEventAsync
fire_handle('renamer.scan',
movie_folder=movie_folder,
download_info={
'id': download_id,
'downloader': downloader
} if download_id else None)
return jsonified({'success': True})
def edit(self):
params = getParams()
db = get_session()
available_status = fireEvent('status.get', 'available', single=True)
ids = splitString(params.get('id'))
for movie_id in ids:
m = db.query(Movie).filter_by(id=movie_id).first()
if not m:
continue
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 = toUnicode(params.get(
'default_title',
'')).lower() == toUnicode(title.title).lower()
db.commit()
fireEvent('movie.restatus', m.id)
movie_dict = m.to_dict(self.default_dict)
fireEventAsync('searcher.single',
movie_dict,
on_complete=self.createNotifyFront(movie_id))
#db.close()
return jsonified({
'success': True,
})
def refresh(self):
params = getParams()
db = get_session()
movie = db.query(Movie).filter_by(id=params.get('id')).first()
# Get current selected title
default_title = ''
for title in movie.library.titles:
if title.default: default_title = title.title
if movie:
#addEvent('library.update.after', )
fireEventAsync('library.update',
library=movie.library,
default_title=default_title)
return jsonified({
'success': True,
})
def search(self):
params = getParams()
cache_key = '%s/%s' % (__name__, urlencode(params))
movies = Env.get('cache').get(cache_key)
if not movies:
results = fireEvent('provider.movie.search', q=params.get('q'))
# Combine movie results
movies = []
for r in results:
movies += r
Env.get('cache').set(cache_key, movies)
return jsonified({
'success': True,
'empty': len(movies) == 0,
'movies': movies,
})
def list(self):
params = getParams()
db = get_session()
# Make a list from string
status = params.get('status', ['active'])
if not isinstance(status, (list, tuple)):
status = [status]
results = db.query(Movie).filter(
or_(*[Movie.status.has(identifier=s) for s in status])).all()
movies = []
for movie in results:
temp = movie.to_dict(self.default_dict)
movies.append(temp)
return jsonified({
'success': True,
'empty': len(movies) == 0,
'movies': movies,
})
def refresh(self):
params = getParams()
db = get_session()
movie = db.query(Movie).filter_by(id=params.get('id')).first()
# Get current selected title
default_title = ''
for title in movie.library.titles:
if title.default: default_title = title.title
if movie:
#addEvent('library.update.after', )
fireEventAsync('library.update',
identifier=movie.library.identifier,
default_title=default_title,
force=True)
fireEventAsync('searcher.single', movie.to_dict(self.default_dict))
return jsonified({
'success': True,
})
def listView(self):
params = getParams()
status = splitString(params.get('status', None))
release_status = splitString(params.get('release_status', None))
limit_offset = params.get('limit_offset', None)
starts_with = params.get('starts_with', None)
search = params.get('search', None)
order = params.get('order', None)
total_movies, movies = self.list(status=status,
release_status=release_status,
limit_offset=limit_offset,
starts_with=starts_with,
search=search,
order=order)
return jsonified({
'success': True,
'empty': len(movies) == 0,
'total': total_movies,
'movies': movies,
})
