def xbmc_get_episodes(xbmc, tvshowid, season): logger.log("LIBRARY :: Retrieving episodes for tvshowid: %s season: %s" % (tvshowid, season), "INFO") version = xbmc.Application.GetProperties(properties=["version"])["version"]["major"] params = {"sort": xbmc_sort("episodes")} if version < 12 and params["sort"]["method"] in ["rating", "playcount", "random"]: # Eden logger.log( 'LIBRARY :: Sort method "%s" is not supported in XBMC Eden. Reverting to "episode"' % params["sort"]["method"], "INFO", ) change_sort("episodes", "episode") params["sort"] = xbmc_sort("episodes") params["tvshowid"] = tvshowid params["season"] = season params["properties"] = [ "playcount", "season", "episode", "tvshowid", "showtitle", "thumbnail", "firstaired", "rating", ] episodes = xbmc.VideoLibrary.GetEpisodes(**params)["episodes"] if get_setting_value("xbmc_episodes_hide_watched") == "1": episodes = [x for x in episodes if not x["playcount"]] return episodes
def server_settings_dialog(server_id=None): """ Server settings dialog. If server_id exists then we're editing a server, otherwise we're adding one. """ server = None if server_id: try: server = XbmcServer.query.get(server_id) except: logger.log('Error retrieving server details for server ID %s' % server_id , 'WARNING') # GET if request.method == 'GET': return render_template('dialogs/server_settings_dialog.html', server = server, ) # POST else: if not server: server = XbmcServer('', 1, '') label = request.form['label'] if not label: label = 'XBMC server' try: server.label = label server.position = request.form['position'] server.hostname = request.form['hostname'] server.port = request.form['port'] server.username = request.form['username'] server.password = request.form['password'] server.mac_address = request.form['mac_address'] db_session.add(server) db_session.commit() active_server = get_setting('active_server') if not active_server: active_server = Setting('active_server', server.id) db_session.add(active_server) db_session.commit() return render_template('includes/servers.html', servers = XbmcServer.query.order_by(XbmcServer.position), ) except: logger.log('Error saving XBMC server to database', 'WARNING') return jsonify({ 'status': 'error' }) return jsonify({ 'status': 'error' })
def xhr_trakt_hated(user, type): logger.log('TRAKT :: Fetching %s\'s hated %s' % (user, type), 'INFO') apikey = get_setting_value('trakt_api_key') url = 'http://api.trakt.tv/user/library/%s/hated.json/%s/%s/' % (type, apikey, user) try: result = urllib.urlopen(url).read() except: logger.log('TRAKT :: Problem fething URL', 'ERROR') return render_template('trakt-base.html', message=url_error) trakt = json.JSONDecoder().decode(result) amount = len(trakt) if trakt == []: trakt = [{'empty': True}] return render_template('trakt-hated.html', hated = trakt, amount = amount, type = type.title(), user = user, title = 'Hated', )
def gitUpdate(): """Update Maraschino using git""" output, err = runGit('pull origin %s' % branch) if not output: logger.log('Couldn\'t download latest version', 'ERROR') maraschino.USE_GIT = False return 'failed' for line in output.split('\n'): if 'Already up-to-date.' in line: logger.log('UPDATER :: Already up to date', 'INFO') logger.log('UPDATER :: Git output: ' + str(output), 'DEBUG') return 'complete' elif line.endswith('Aborting.'): logger.log('UPDATER :: Unable to update from git: '+line, 'ERROR') logger.log('UPDATER :: Output: ' + str(output), 'DEBUG') maraschino.USE_GIT = False return 'failed' maraschino.CURRENT_COMMIT = maraschino.LATEST_COMMIT writeVersion(maraschino.LATEST_COMMIT) maraschino.COMMITS_BEHIND = 0 return 'complete'
def xhr_headphones_album(albumid, mobile=False): logger.log('HEADPHONES :: Fetching album', 'INFO') try: headphones = headphones_api('getAlbum&id=%s' % albumid) except Exception as e: return headphones_exception(e) album = headphones['album'][0] try: album['ThumbURL'] = hp_albumart(album['AlbumID']) except: pass album['TotalDuration'] = 0 for track in headphones['tracks']: if track['TrackDuration'] == None: track['TrackDuration'] = 0 album['TotalDuration'] = album['TotalDuration'] + int(track['TrackDuration']) track['TrackDuration'] = convert_track_duration(track['TrackDuration']) album['TotalDuration'] = convert_track_duration(album['TotalDuration']) album['Tracks'] = len(headphones['tracks']) if mobile: return headphones return render_template('headphones/album.html', album=headphones, headphones=True, compact=hp_compact(), )
def start_script(script_id): #first get the script we want script = None message = None script = Script.query.filter(Script.id == script_id).first() now = datetime.datetime.now() command = os.path.join(maraschino.SCRIPT_DIR,script.script) if (script.parameters): command = ''.join([command, ' ', script.parameters]) #Parameters needed for scripts that update host = maraschino.HOST port = maraschino.PORT webroot = maraschino.WEBROOT if not webroot: webroot = '/' file_ext = os.path.splitext(script.script)[1] if (file_ext == '.py'): if (script.updates == 1): #these are extra parameters to be passed to any scripts ran, so they #can update the status if necessary extras = '--i "%s" --p "%s" --s "%s" --w "%s"' % (host, port, script.id, webroot) #the command in all its glory command = ''.join([command, ' ', extras]) script.status="Script Started at: %s" % now.strftime("%m-%d-%Y %H:%M") else: script.status="Last Ran: %s" % now.strftime("%m-%d-%Y %H:%M") command = ''.join(['python ', command]) elif (file_ext in ['.sh', '.pl', '.cmd']): if (script.updates == 1): extras = '%s %s %s %s' % (host, port, script.id, webroot) #the command in all its glory command = ''.join([command, ' ', extras]) script.status="Script Started at: %s" % now.strftime("%m-%d-%Y %H:%M") else: script.status="Last Ran: %s" % now.strftime("%m-%d-%Y %H:%M") if(file_ext == '.pl'): command = ''.join(['perl ', command]) if(file_ext == '.cmd'): command = ''.join([command]) logger.log('SCRIPT_LAUNCHER :: %s' % command, 'INFO') #now run the command subprocess.Popen(command, shell=True) db_session.add(script) db_session.commit() return script_launcher()
def xhr_headphones_artist_action(artistid, action, mobile=False): if action == "pause": logger.log("HEADPHONES :: Pausing artist", "INFO") command = "pauseArtist&id=%s" % artistid elif action == "resume": logger.log("HEADPHONES :: Resuming artist", "INFO") command = "resumeArtist&id=%s" % artistid elif action == "refresh": logger.log("HEADPHONES :: Refreshing artist", "INFO") command = "refreshArtist&id=%s" % artistid elif action == "remove": logger.log("HEADPHONES :: Removing artist", "INFO") command = "delArtist&id=%s" % artistid elif action == "add": logger.log("HEADPHONES :: Adding artist", "INFO") command = "addArtist&id=%s" % artistid try: if command == "remove": headphones_api(command, False) elif command == "pause": headphones_api(command, False) elif command == "resume": headphones_api(command, False) else: Thread(target=headphones_api, args=(command, False)).start() except Exception as e: if mobile: headphones_exception(e) return jsonify(error="failed") return headphones_exception(e) return jsonify(status="successful")
def xhr_trakt_trending(type=None, mobile=False): if not type: type = get_setting_value('trakt_default_media') limit = int(get_setting_value('trakt_trending_limit')) logger.log('TRAKT :: Fetching trending %s' % type, 'INFO') url = 'http://api.trakt.tv/%s/trending.json/%s' % (type, trakt_apikey()) try: trakt = trak_api(url) except Exception as e: trakt_exception(e) return render_template('traktplus/trakt-base.html', message=e) if mobile: return trakt if len(trakt) > limit: trakt = trakt[:limit] for item in trakt: item['images']['poster'] = cache_image(item['images']['poster'], type) while THREADS: time.sleep(1) return render_template('traktplus/trakt-trending.html', trending=trakt, type=type.title(), title='Trending', )
def xhr_headphones_artists(mobile=False): logger.log("HEADPHONES :: Fetching artists list", "INFO") artists = [] try: headphones = headphones_api("getIndex") updates = headphones_api("getVersion") except Exception as e: if mobile: headphones_exception(e) return artists return headphones_exception(e) for artist in headphones: if not "Fetch failed" in artist["ArtistName"]: try: artist["Percent"] = int(100 * float(artist["HaveTracks"]) / float(artist["TotalTracks"])) except: artist["Percent"] = 0 if not hp_compact() and not mobile: try: artist["ThumbURL"] = hp_artistart(artist["ArtistID"]) except: pass artists.append(artist) if mobile: return artists return render_template( "headphones-artists.html", headphones=True, artists=artists, updates=updates, compact=hp_compact() )
def download_image(image, file_path): try: logger.log('TRAKT :: Creating file %s' % file_path, 'INFO') downloaded_image = file(file_path, 'wb') except: logger.log('TRAKT :: Failed to create file %s' % file_path, 'ERROR') logger.log('TRAKT :: Using remote image', 'INFO') threads.pop() return image try: logger.log('TRAKT :: Downloading %s' % image, 'INFO') image_on_web = urllib.urlopen(image) while True: buf = image_on_web.read(65536) if len(buf) == 0: break downloaded_image.write(buf) downloaded_image.close() image_on_web.close() except: logger.log('TRAKT :: Failed to download %s' % image, 'ERROR') threads.pop() return
def album_library(artistid): try: xbmc = jsonrpclib.Server(server_api_address()) version = xbmc.Application.GetProperties(properties=['version'])['version']['major'] params = {'sort': {'ignorearticle': True}, 'properties': ['year']} if version < 12: # Eden params['artistid'] = artistid params['properties'].extend(['artistid', 'artist']) else: # Frodo params['filter'] = {'artistid': artistid} albums = xbmc.AudioLibrary.GetAlbums(**params)['albums'] if version > 11: # Frodo artist = xbmc.AudioLibrary.GetArtistDetails(artistid=artistid)['artistdetails']['label'] for album in albums: album['artistid'] = artistid album['artist'] = artist except: logger.log('Mobile :: XBMC :: Could not retrieve albums from audio library', 'WARNING') albums = [] return render_template('mobile/xbmc/albums.html', albums=albums, )
def sabnzbd_history_item(id): global sabnzbd_history_slots if sabnzbd_history_slots: for item in sabnzbd_history_slots['slots']: if item['nzo_id'] == id: return render_template('mobile/sabnzbd/history_item.html', item=item, ) return sabnzbd_history() else: try: sabnzbd = sabnzbd_api(method='history', params='&limit=50') sabnzbd = sabnzbd_history_slots = sabnzbd['history'] for item in sabnzbd_history_slots['slots']: if item['nzo_id'] == id: return render_template('mobile/sabnzbd/history_item.html', item=item, ) except Exception as e: logger.log('Mobile :: SabNZBd+ :: Could not retrieve SabNZBd - %s]' % (e), 'WARNING') sabnzbd = None return render_template('mobile/sabnzbd/history.html', history=sabnzbd, )
def runGit(args): """Run git command with args as arguments""" git_locations = ['git'] if platform.system().lower() == 'darwin': git_locations.append('/usr/local/git/bin/git') output = err = None for cur_git in git_locations: cmd = cur_git + ' ' + args try: logger.log('UPDATER :: Trying to execute: "' + cmd + '" with shell in ' + RUNDIR, 'DEBUG') p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True, cwd=RUNDIR) output, err = p.communicate() logger.log('UPDATER :: Git output: ' + output, 'DEBUG') except OSError: logger.log('UPDATER :: Command ' + cmd + ' didn\'t work, couldn\'t find git', 'WARNING') continue if 'not found' in output or "not recognized as an internal or external command" in output: logger.log('UPDATER :: Unable to find git with command ' + cmd, 'WARNING') output = None elif 'fatal:' in output or err: logger.log('UPDATER :: Git returned bad info. Are you sure this is a git installation?', 'WARNING') output = None elif output: break return (output, err)
def create_dir(dir): if not os.path.exists(dir): try: logger.log('TRAKT :: Creating dir %s' % dir, 'INFO') os.makedirs(dir) except: logger.log('TRAKT :: Problem creating dir %s' % dir, 'ERROR')
def xhr_trakt_trending(type): logger.log('TRAKT :: Fetching trending %s' % type, 'INFO') apikey = get_setting_value('trakt_api_key') url = 'http://api.trakt.tv/%s/trending.json/%s' % (type, apikey) try: result = urllib.urlopen(url).read() except: logger.log('TRAKT :: Problem fething URL', 'ERROR') return render_template('trakt-base.html', message=url_error) trakt = json.JSONDecoder().decode(result) if len(trakt) > 20: trakt = trakt[:20] for item in trakt: item['images']['poster'] = cache_image(item['images']['poster'], type) while threads: time.sleep(1) return render_template('trakt-trending.html', trending = trakt, type = type.title(), title = 'Trending', )
def tutorial_save(): global user, servers # save login and password on db try: settings = json.JSONDecoder().decode(request.form['settings']) for s in settings: setting = get_setting(s['name']) if not setting: setting = Setting(s['name']) setting.value = s['value'] db_session.add(setting) db_session.commit() logger.log('Plex :: Successfully saved Plex credentials', 'INFO') except: return jsonify(success=False, msg='Failed to save plex credentials to db') # Delete info for previous accounts try: PlexServer.query.delete() except: logger.log('Plex :: Failed to delete old server info', 'WARNING') try: if loginToPlex(): # login to plex servers = getServers() if servers: # retrieve servers return jsonify(success=True, servers=listServers()) else: return jsonify(sucess=False, msg='Failed to retrieve servers') else: return jsonify(sucess=False, msg='Failed to login to plex') except: return jsonify(success=False, msg='Servers not populated Successfully')
def xhr_trakt_recommendations(type=None, mobile=False): if not type: type = get_setting_value('trakt_default_media') logger.log('TRAKT :: Fetching %s recommendations' % type, 'INFO') url = 'http://api.trakt.tv/recommendations/%s/%s' % (type, trakt_apikey()) params = { 'hide_collected': True, 'hide_watchlisted': True } try: recommendations = trak_api(url, params) except Exception as e: trakt_exception(e) return render_template('traktplus/trakt-base.html', message=e) random.shuffle(recommendations) for item in recommendations: item['poster'] = cache_image(item['images']['poster'], type) while THREADS: time.sleep(1) if mobile: return recommendations return render_template('traktplus/trakt-recommendations.html', type=type.title(), recommendations=recommendations, title='Recommendations', )
def xhr_trakt_friends(user=None, mobile=False): logger.log('TRAKT :: Fetching friends list', 'INFO') pending = [] if not user: friends_url = 'http://api.trakt.tv/user/friends.json/%s/%s' % (trakt_apikey(), get_setting_value('trakt_username')) pending_url = 'http://api.trakt.tv/friends/requests/%s' % trakt_apikey() else: friends_url = 'http://api.trakt.tv/user/friends.json/%s/%s' % (trakt_apikey(), user) try: friends = trak_api(friends_url) if not user: pending = trak_api(pending_url) except Exception as e: trakt_exception(e) return render_template('traktplus/trakt-base.html', message=e) if mobile: return friends return render_template('traktplus/trakt-friends.html', friends=friends, pending=pending, title='Friends', )
def json_login(): if not loginToPlex(): return jsonify(success=False, msg='Failed to login to plex.tv, plese make sure this is a valid username/password.') # Delete info for previous accounts try: PlexServer.query.delete() except: logger.log('Plex :: Failed to delete old server info', 'WARNING') # Populate servers for new user if not getServers(): return jsonify(success=False, msg='Failed to retrieve server information from https://plex.tv/pms/servers.') # Set active server to 0 (no server selected) try: active_server = get_setting('active_server') if not active_server: active_server = Setting('active_server', 0) db_session.add(active_server) db_session.commit() else: active_server.value = 0 db_session.add(active_server) db_session.commit() except: logger.log('Plex :: Failed to reset server, please make sure to select new one.', 'WARNING') # return a list of (server name, server id) return jsonify(success=True, servers=listServers())
def xhr_headphones_artists(): logger.log('HEADPHONES :: Fetching artists list', 'INFO') try: headphones = headphones_api('getIndex') updates = headphones_api('getVersion') except Exception as e: return headphones_exception(e) artists = [] for artist in headphones: if not 'Fetch failed' in artist['ArtistName']: try: artist['Percent'] = int(100 * float(artist['HaveTracks']) / float(artist['TotalTracks'])) except: artist['Percent'] = 0 if not hp_compact(): try: artist['ThumbURL'] = hp_artistart(artist['ArtistID']) except: pass artists.append(artist) return render_template('headphones-artists.html', headphones=True, artists=artists, updates=updates, compact=hp_compact(), )
def loginToPlex(username=None, password=None): global user if username is None: if not get_setting_value('myPlex_username') or not get_setting_value('myPlex_password'): logger.log('Plex :: Missing Plex Credentials in db', 'INFO') return False else: username = get_setting_value('myPlex_username') password = get_setting_value('myPlex_password') logger.log('Plex :: Logging into plex.tv', 'INFO') try: user = User(username, password) user, token = user.MyPlexSignIn() if user is '': logger.log('Plex :: Log in FAILED', 'ERROR') return False # failed to sign in setting = get_setting('myPlex_token') if not setting: setting = Setting('myPlex_token') setting.value = token db_session.add(setting) db_session.commit() logger.log('Plex :: Log in successful', 'INFO') return True except: logger.log('Plex :: Log in FAILED', 'ERROR') return False
def xhr_library_info(type, id): logger.log('LIBRARY :: Retrieving %s details' % type, 'INFO') xbmc = jsonrpclib.Server(server_api_address()) try: if type == 'movie': library = xbmc.VideoLibrary.GetMovieDetails(movieid=id, properties=['title', 'rating', 'year', 'genre', 'plot', 'director', 'thumbnail', 'trailer', 'playcount', 'resume']) title = library['moviedetails']['title'] elif type == 'tvshow': library = xbmc.VideoLibrary.GetTVShowDetails(tvshowid=id, properties=['title', 'rating', 'year', 'genre', 'plot', 'premiered', 'thumbnail', 'playcount', 'studio']) title = library['tvshowdetails']['title'] elif type == 'episode': library = xbmc.VideoLibrary.GetEpisodeDetails(episodeid=id, properties=['season', 'tvshowid', 'title', 'rating', 'plot', 'thumbnail', 'playcount', 'firstaired', 'resume']) title = library['episodedetails']['title'] elif type == 'artist': library = xbmc.AudioLibrary.GetArtistDetails(artistid=id, properties=['description', 'thumbnail', 'genre']) title = library['artistdetails']['label'] elif type == 'album': library = xbmc.AudioLibrary.GetAlbumDetails(albumid=id, properties=['artistid', 'title', 'artist', 'year', 'genre', 'description', 'albumlabel', 'rating', 'thumbnail']) title = library['albumdetails']['title'] except: logger.log('LIBRARY :: %s' % xbmc_error, 'ERROR') return render_library(message=xbmc_error) return render_library(library, title)
def xhr_headphones_album(albumid, mobile=False): logger.log("HEADPHONES :: Fetching album", "INFO") try: headphones = headphones_api("getAlbum&id=%s" % albumid) except Exception as e: return headphones_exception(e) album = headphones["album"][0] try: album["ThumbURL"] = hp_albumart(album["AlbumID"]) except: pass album["TotalDuration"] = 0 for track in headphones["tracks"]: if track["TrackDuration"] == None: track["TrackDuration"] = 0 album["TotalDuration"] = album["TotalDuration"] + int(track["TrackDuration"]) track["TrackDuration"] = convert_track_duration(track["TrackDuration"]) album["TotalDuration"] = convert_track_duration(album["TotalDuration"]) album["Tracks"] = len(headphones["tracks"]) if mobile: return headphones return render_template("headphones-album.html", album=headphones, headphones=True, compact=hp_compact())
def mobile_trakt_summary(media, id, season=None, episode=None): summary = xhr_trakt_summary(type=media, id=id, season=season, episode=episode, mobile=True) if 'genres' in summary: summary['genres'] = " / ".join(summary['genres']) if media == 'show': url = 'http://api.trakt.tv/show/shouts.json/%s/%s' % (trakt_apikey(), id) elif media == 'episode': url = 'http://api.trakt.tv/show/episode/shouts.json/%s/%s/%s/%s' % (trakt_apikey(), id, season, episode) else: url = 'http://api.trakt.tv/movie/shouts.json/%s/%s' % (trakt_apikey(), id) try: shouts = trak_api(url) except: logger.log('TRAKT :: Failed to retrieve shouts for %s: %s' % (media, id), 'ERROR') shouts = [] return render_template('mobile/trakt/summary.html', summary=summary, shouts=shouts, media=media )
def xbmc_get_moviesets(xbmc, setid): logger.log("LIBRARY :: Retrieving movie set: %s" % setid, "INFO") version = xbmc.Application.GetProperties(properties=["version"])["version"]["major"] sort = xbmc_sort("movies") properties = ["playcount", "thumbnail", "year", "rating", "set"] params = {"sort": sort, "properties": properties} if version == 11: # Eden params["properties"].append("setid") else: # Frodo params["filter"] = {"setid": setid} movies = xbmc.VideoLibrary.GetMovies(**params)["movies"] if version == 11: # Eden movies = [x for x in movies if setid in x["setid"]] setlabel = xbmc.VideoLibrary.GetMovieSetDetails(setid=setid)["setdetails"]["label"] for movie in movies: movie["set"] = setlabel if get_setting_value("xbmc_movies_hide_watched") == "1": movies = [x for x in movies if not x["playcount"]] movies[0]["setid"] = setid return movies
def xbmc_get_seasons(xbmc, tvshowid): logger.log("LIBRARY :: Retrieving seasons for tvshowid: %s" % tvshowid, "INFO") version = xbmc.Application.GetProperties(properties=["version"])["version"]["major"] params = {"sort": xbmc_sort("seasons")} if version < 12 and params["sort"]["method"] in ["rating", "playcount", "random"]: # Eden logger.log( 'LIBRARY :: Sort method "%s" is not supported in XBMC Eden. Reverting to "label"' % params["sort"]["method"], "INFO", ) change_sort("seasons", "label") params["sort"] = xbmc_sort("seasons") params["tvshowid"] = tvshowid params["properties"] = ["playcount", "showtitle", "tvshowid", "season", "thumbnail", "episode"] seasons = xbmc.VideoLibrary.GetSeasons(**params)["seasons"] if get_setting_value("xbmc_seasons_hide_watched") == "1": seasons = [x for x in seasons if not x["playcount"]] # Add episode playcounts to seasons for season in seasons: episodes = xbmc.VideoLibrary.GetEpisodes(tvshowid=tvshowid, season=season["season"], properties=["playcount"])[ "episodes" ] season["unwatched"] = len([x for x in episodes if not x["playcount"]]) return seasons
def xhr_sickrage(): params = '/?cmd=future&sort=date' try: sickrage = sickrage_api(params) compact_view = get_setting_value('sickrage_compact') == '1' show_airdate = get_setting_value('sickrage_airdate') == '1' if sickrage['result'].rfind('success') >= 0: logger.log('SICKRAGE :: Successful API call to %s' % params, 'DEBUG') sickrage = sickrage['data'] for time in sickrage: for episode in sickrage[time]: episode['image'] = get_pic(episode['indexerid'], 'banner') logger.log('SICKRAGE :: Successful %s' % (episode['image']), 'DEBUG') except: return render_template('sickrage.html', sickrage='', ) return render_template('sickrage.html', url=sickrage_url_no_api(), app_link=sickrage_url_no_api(), sickrage=sickrage, missed=sickrage['missed'], today=sickrage['today'], soon=sickrage['soon'], later=sickrage['later'], compact_view=compact_view, show_airdate=show_airdate, )
def xhr_trakt_watchlist(user, type=None, mobile=False): if not type: type = get_setting_value('trakt_default_media') logger.log('TRAKT :: Fetching %s\'s %s watchlist' % (user, type), 'INFO') url = 'http://api.trakt.tv/user/watchlist/%s.json/%s/%s/' % (type, trakt_apikey(), user) try: trakt = trak_api(url) except Exception as e: trakt_exception(e) return render_template('traktplus/trakt-base.html', message=e) if mobile: return trakt if trakt == []: trakt = [{'empty': True}] return render_template('traktplus/trakt-watchlist.html', watchlist=trakt, type=type.title(), user=user, title='Watchlist', )
def xhr_trakt_get_lists(user=None, mobile=False): if not user: user = get_setting_value('trakt_username') logger.log('TRAKT :: Fetching %s\'s custom lists' % user, 'INFO') url = 'http://api.trakt.tv/user/lists.json/%s/%s' % (trakt_apikey(), user) try: trakt = trak_api(url) except Exception as e: trakt_exception(e) return render_template('traktplus/trakt-base.html', message=e) if request.method == 'GET': if mobile: return trakt return render_template('traktplus/trakt-custom_lists.html', lists=trakt, user=user, title='lists' ) else: return render_template('traktplus/trakt-add_to_list.html', lists=trakt, custom_lists=True, media=request.form, )
def xhr_headphones_artist_action(artistid, action, mobile=False): if action == 'pause': logger.log('HEADPHONES :: Pausing artist', 'INFO') command = 'pauseArtist&id=%s' % artistid elif action == 'resume': logger.log('HEADPHONES :: Resuming artist', 'INFO') command = 'resumeArtist&id=%s' % artistid elif action == 'refresh': logger.log('HEADPHONES :: Refreshing artist', 'INFO') command = 'refreshArtist&id=%s' % artistid elif action == 'remove': logger.log('HEADPHONES :: Removing artist', 'INFO') command = 'delArtist&id=%s' % artistid elif action == 'add': logger.log('HEADPHONES :: Adding artist', 'INFO') command = 'addArtist&id=%s' % artistid try: if command == 'remove': headphones_api(command, False) elif command == 'pause': headphones_api(command, False) elif command == 'resume': headphones_api(command, False) else: Thread(target=headphones_api, args=(command, False)).start() except Exception as e: if mobile: headphones_exception(e) return jsonify(error='failed') return headphones_exception(e) return jsonify(status='successful')
def add_edit_script(): logger.log('SCRIPT_LAUNCHER :: add_edit_script() ', 'DEBUG') script = request.form['script_file'] label = request.form['label'] parameters = request.form['parameters'] updates = 0 try: if (request.form['type']): updates = 1 except: pass #Check that we have the command and label if script == '': return jsonify({ 'status': 'Command Required' }) if label == '': return jsonify({ 'status': 'Label Required' }) #figure out if it is a new script or existing script if 'script_id' in request.form: db_script = Script.query.filter(Script.id == request.form['script_id']).first() db_script.script = script db_script.label = label db_script.parameters = parameters db_script.updates = updates else: db_script = Script(label,script, parameters,updates) #save it to the database try: db_session.add(db_script) db_session.commit() except Exception, e: logger.log('SCRIPT_LAUNCHER :: Add Failed', 'ERROR') return jsonify({ 'status': 'Add Failed' })
def xhr_headphones_artists(mobile=False): logger.log('HEADPHONES :: Fetching artists list', 'INFO') artists = [] try: headphones = headphones_api('getIndex') updates = headphones_api('getVersion') except Exception as e: if mobile: headphones_exception(e) return artists return headphones_exception(e) for artist in headphones: if not 'Fetch failed' in artist['ArtistName']: try: artist['Percent'] = int(100 * float(artist['HaveTracks']) / float(artist['TotalTracks'])) except: artist['Percent'] = 0 if not hp_compact() and not mobile: try: artist['ThumbURL'] = hp_artistart(artist['ArtistID']) except: pass artists.append(artist) if mobile: return artists return render_template('headphones-artists.html', headphones=True, artists=artists, updates=updates, compact=hp_compact(), )
def xhr_notify_message(): label = str(request.form['label']) hostname = str(request.form['hostname']) message = str(request.form['message']) title = str(request.form['title']) port = 9777 icon = os.path.join(RUNDIR, 'static', 'images', 'notifications', request.form['image']) if title == "Title": title = "Maraschino" if not os.path.exists(icon): icon = os.path.join(RUNDIR, 'static', 'images', 'maraschino_logo.png') if icon[-3:] == "png": icon_type = ICON_PNG elif icon[-3:] == "jpg": icon_type = ICON_JPEG elif icon[-4:] == "jpeg": icon_type = ICON_JPEG elif icon[-3:] == "gif": icon_type = ICON_GIF else: icon_type = ICON_NONE addr = (hostname, port) sock = socket(AF_INET, SOCK_DGRAM) try: logger.log('NOTIFY XBMC :: Sending message to %s' % label, 'INFO') packet = PacketNOTIFICATION(title, message, icon_type, icon) packet.send(sock, addr) return jsonify({'status': 'successful'}) except: logger.log('NOTIFY XBMC :: Message failed to send', 'ERROR') return jsonify({'error': 'Message failed to send'})
def xbmc_get_songs(xbmc, artistid, albumid): logger.log('LIBRARY :: Retrieving songs for albumid: %s' % albumid, 'INFO') version = xbmc.Application.GetProperties( properties=['version'])['version']['major'] params = {'sort': xbmc_sort('songs')} if version < 12 and params['sort']['method'] in [ 'rating', 'playcount', 'random' ]: #Eden logger.log( 'LIBRARY :: Sort method "%s" is not supported in XBMC Eden. Reverting to "track"' % params['sort']['method'], 'INFO') change_sort('songs', 'track') params['sort'] = xbmc_sort('songs') params['properties'] = [ 'album', 'track', 'playcount', 'year', 'albumid', 'thumbnail', 'rating', 'title', 'duration', 'artist' ] if version == 11: #Eden params['artistid'] = artistid params['albumid'] = albumid else: #Frodo params['filter'] = {'albumid': albumid} songs = xbmc.AudioLibrary.GetSongs(**params)['songs'] for song in songs: song['artistid'] = artistid song['label'] = '%02d. %s' % (song['track'], song['title']) if isinstance(song['artist'], list): #Frodo song['artist'] = " / ".join(song['artist']) return songs
def xhr_headphones_search(type, query, mobile=False): if type == 'artist': logger.log('HEADPHONES :: Searching for artist', 'INFO') command = 'findArtist&name=%s' % urllib.quote(query) else: logger.log('HEADPHONES :: Searching for album', 'INFO') command = 'findAlbum&name=%s' % urllib.quote(query) try: headphones = headphones_api(command) except Exception as e: return headphones_exception(e) for artist in headphones: artist['url'].replace('\/', '/') if mobile: return headphones return render_template('headphones/search_dialog.html', headphones=True, search=headphones, query=query )
def xhr_trakt_watchlist(user, type=None): if not type: type = get_setting_value('trakt_default_media') logger.log('TRAKT :: Fetching %s\'s %s watchlist' % (user, type), 'INFO') url = 'http://api.trakt.tv/user/watchlist/%s.json/%s/%s/' % ( type, trakt_apikey(), user) try: trakt = trak_api(url) except Exception as e: trakt_exception(e) return render_template('traktplus/trakt-base.html', message=e) if trakt == []: trakt = [{'empty': True}] return render_template( 'traktplus/trakt-watchlist.html', watchlist=trakt, type=type.title(), user=user, title='Watchlist', )
def xhr_headphones_control(command): if command == 'shutdown': logger.log('HEADPHONES :: Shutting down', 'INFO') elif command == 'restart': logger.log('HEADPHONES :: Restarting', 'INFO') elif command == 'update': logger.log('HEADPHONES :: Updating', 'INFO') elif command == 'force_search': logger.log('HEADPHONES :: Forcing wanted album search', 'INFO') command = 'forceSearch' elif command == 'force_process': logger.log('HEADPHONES :: Forcing post process', 'INFO') command = 'forceProcess' try: Thread(target=headphones_api, args=(command, False)).start() except Exception as e: return headphones_exception(e) return jsonify(status='successful')
def xhr_trakt_library(user, type=None, mobile=False): if not type: type = get_setting_value('trakt_default_media') logger.log('TRAKT :: Fetching %s\'s %s library' % (user, type), 'INFO') url = 'http://api.trakt.tv/user/library/%s/all.json/%s/%s' % ( type, trakt_apikey(), user) try: trakt = trak_api(url) except Exception as e: trakt_exception(e) return render_template('traktplus/trakt-base.html', message=e) if mobile: return trakt return render_template( 'traktplus/trakt-library.html', library=trakt, user=user, type=type.title(), title='Library', )
def xhr_library_resume_check(type, id): logger.log('LIBRARY :: Checking if %s has resume position' % type, 'INFO') xbmc = jsonrpclib.Server(server_api_address()) try: if type == 'movie': library = xbmc.VideoLibrary.GetMovieDetails(movieid=id, properties=['resume']) elif type == 'episode': library = xbmc.VideoLibrary.GetEpisodeDetails(episodeid=id, properties=['resume']) except: logger.log('LIBRARY :: %s' % xbmc_error, 'ERROR') return render_library(message=xbmc_error) position = library[type + 'details']['resume']['position'] if position: position = format_seconds(position) template = render_template('dialogs/library-resume_dialog.html', position=position, library=library) return jsonify(resume=True, template=template) else: return jsonify(resume=False, template=None)
def xhr_headphones_album(albumid, mobile=False): logger.log('HEADPHONES :: Fetching album', 'INFO') try: headphones = headphones_api('getAlbum&id=%s' % albumid) except Exception as e: return headphones_exception(e) album = headphones['album'][0] try: album['ThumbURL'] = hp_albumart(album['AlbumID']) except: pass album['TotalDuration'] = 0 for track in headphones['tracks']: if track['TrackDuration'] == None: track['TrackDuration'] = 0 album['TotalDuration'] = album['TotalDuration'] + int( track['TrackDuration']) track['TrackDuration'] = convert_track_duration(track['TrackDuration']) album['TotalDuration'] = convert_track_duration(album['TotalDuration']) album['Tracks'] = len(headphones['tracks']) if mobile: return headphones return render_template( 'headphones/album.html', album=headphones, app_link=headphones_url(), headphones=True, compact=hp_compact(), )
def xhr_headphones_artist(artistid, mobile=False): logger.log('HEADPHONES :: Fetching artist', 'INFO') try: albums = headphones_api('getArtist&id=%s' % artistid) except Exception as e: return headphones_exception(e) if not hp_compact() and not mobile: for album in albums['albums']: try: album['ThumbURL'] = hp_albumart(album['AlbumID']) except: pass if mobile: return albums return render_template( 'headphones/artist.html', albums=albums, headphones=True, compact=hp_compact(), )
def xbmc_get_albums(xbmc, artistid): logger.log('LIBRARY :: Retrieving albums for artistid: %s' % artistid, 'INFO') version = xbmc.Application.GetProperties(properties=['version'])['version']['major'] params = {} params['sort'] = xbmc_sort('albums') params['properties'] = ['year', 'rating', 'thumbnail'] if version == 11: #Eden params['artistid'] = artistid params['properties'].extend(['artistid', 'artist']) else: #Frodo params['filter'] = {'artistid':artistid} albums = xbmc.AudioLibrary.GetAlbums(**params)['albums'] if version > 11: #Frodo artist = xbmc.AudioLibrary.GetArtistDetails(artistid=artistid)['artistdetails']['label'] for album in albums: album['artistid'] = artistid album['artist'] = artist return albums
def get_recently_added_albums(xbmc, album_offset=0, mobile=False): num_recent_albums = get_num_recent_albums() xbmc_label = get_recent_xbmc_label('recently_added_albums_server') using_db = False try: recently_added_albums = xbmc.AudioLibrary.GetRecentlyAddedAlbums( properties=['title', 'year', 'rating', 'artist', 'thumbnail' ])['albums'] recently_added_db_add(xbmc_label, 'albums', recently_added_albums) thumbs = [ recent_image_file(xbmc_label, 'albums', x['albumid'])[1] for x in recently_added_albums ] cache_dir = os.path.join(DATA_DIR, 'cache', 'xbmc', xbmc_label, 'recent_albums') try: remove_recent_images(cache_dir, thumbs) except: logger.log('Failed to delete old images from %s' % cache_dir, 'WARNING') for album in recently_added_albums: album['thumbnail'] = cache_recent_image(xbmc_label, 'albums', album['albumid'], album['thumbnail']) except: recently_added_albums = [] if not recently_added_albums: try: logger.log('Using cached recently added albums', 'INFO') recently_added_albums = RecentlyAdded.query.filter( RecentlyAdded.name == '%s_albums' % xbmc_label).first().data for album in recently_added_albums: thumb = recent_image_file(xbmc_label, 'albums', album['albumid']) album['thumbnail'] = thumb[0] + thumb[1] using_db = True except: recently_added_movies = [] logger.log('Failed to get recently added albums from database', 'ERROR') if not mobile and recently_added_albums: recently_added_albums = recently_added_albums[ album_offset:num_recent_albums + album_offset] return [recently_added_albums, using_db]
def nzb_su(item, cat=None, mobile=False): API = get_setting_value('nzb_su_API') if not API: logger.log('SEARCH :: NZB.su API missing', 'DEBUG') return jsonify({'error': "Missing NZB.su API"}) nzb = nzbsu(apiKey=API) if item is not '': if cat: logger.log( 'SEARCH :: NZB.su :: Searching for "%s" in category: %s' % (item, cat), 'INFO') result = nzb.Search(query=item, catId=cat) else: logger.log( 'SEARCH :: NZB.su :: Searching for "%s" in all categories' % (item), 'INFO') result = nzb.Search(item) for x in result['channel']['item']: x['link'] = urllib.quote(x['link']) logger.log( 'SEARCH :: NZB.su :: Found %i results for %s' % (len(result['channel']['item']), item), 'INFO') else: result = '' if mobile: return result return render_template( 'search-nzbsu.html', site='nzb.su', results=result['channel']['item'], item=item, categories=cat_newznab, )
def add_edit_script_dialog(script_id=None): logger.log('SCRIPT_LAUNCHER :: add_edit_script_dialog', 'DEBUG') script = None logger.log('SCRIPT_LAUNCHER :: Getting file list', 'DEBUG') script_files = get_file_list( folder = maraschino.SCRIPT_DIR, extensions = ['.py', '.sh', '.pl', '.cmd'], prepend_path = False, prepend_path_minus_root = True ) logger.log('SCRIPT_LAUNCHER :: Have file list', 'DEBUG') if script_id: try: script = Script.query.filter(Script.id == script_id).first() except: pass logger.log('SCRIPT_LAUNCHER :: Rendering remplate add_edit_script_dialog.html', 'DEBUG') return render_template('add_edit_script_dialog.html', script = script, script_files = script_files, )
def get_recently_added_movies(xbmc, movie_offset=0, mobile=False): num_recent_videos = get_num_recent_movies() xbmc_label = get_recent_xbmc_label('recently_added_movies_server') total_movies = 0 using_db = False try: recently_added_movies = xbmc.VideoLibrary.GetRecentlyAddedMovies(properties = ['title', 'year', 'rating', 'playcount', 'thumbnail'])['movies'] recently_added_db_add(xbmc_label, 'movies', recently_added_movies) thumbs = [recent_image_file(xbmc_label, 'movies', x['movieid'])[1] for x in recently_added_movies] cache_dir = os.path.join(DATA_DIR, 'cache', 'xbmc', xbmc_label, 'recent_movies') try: remove_recent_images(cache_dir, thumbs) except: logger.log('Failed to delete old images from %s' % cache_dir, 'WARNING') for movie in recently_added_movies: movie['thumbnail'] = cache_recent_image(xbmc_label, 'movies', movie['movieid'], movie['thumbnail']) except: recently_added_movies = [] if not recently_added_movies: try: logger.log('Using cached recently added movies', 'INFO') recently_added_movies = RecentlyAdded.query.filter(RecentlyAdded.name == '%s_movies' % xbmc_label).first().data for movie in recently_added_movies: thumb = recent_image_file(xbmc_label, 'movies', movie['movieid']) movie['thumbnail'] = thumb[0] + thumb[1] using_db = True except: recently_added_movies = [] logger.log('Failed to get recently added movies from database', 'ERROR') if recently_added_movies: if get_setting_value('recently_added_watched_movies') == '0': recently_added_movies = get_unwatched(recently_added_movies) if mobile: return [recently_added_movies, using_db] if recently_added_movies: total_movies = len(recently_added_movies) recently_added_movies = recently_added_movies[movie_offset:num_recent_videos + movie_offset] return [recently_added_movies, total_movies, using_db]
def xhr_play_file(file_type): logger.log('CONTROLS :: Playing %s file' % file_type, 'INFO') xbmc = jsonrpclib.Server(server_api_address()) if file_type == "music": file_type = "audio" id = 0 else: id = 1 try: xhr_clear_playlist(id) except: logger.log('CONTROLS :: Failed to clear %s playlist' % file_type, 'DEBUG') return jsonify({'failed': True}) file = request.form['file'] file = urllib.unquote(file.encode('ascii')).decode('utf-8') if file_type == "video": player = 1 else: player = 0 try: item = {'file': file} xbmc.Playlist.Add(playlistid=player, item=item) except: logger.log('CONTROLS :: Failed to add %s to playlist' % file_type, 'DEBUG') return jsonify({'failed': True}) try: item = {'playlistid': player} xbmc.Player.Open(item) except: logger.log('CONTROLS :: Failed to open %s' % file_type, 'DEBUG') return jsonify({'failed': True}) return jsonify({'success': True})
def switch_server(server_id=None): """ Switches Plex servers manually. """ try: active_server = get_setting('active_server') if not active_server: active_server = Setting('active_server', 0) db_session.add(active_server) db_session.commit() server = PlexServer.query.filter(PlexServer.id == server_id).first() if server: active_server.value = server_id db_session.add(active_server) db_session.commit() logger.log('Switched active server to ID %s' % server_id, 'INFO') try: status, msg = plex_update_sections(server_id) if not status: logger.log('Plex :: %s' % msg, 'ERROR') except Exception as e: return jsonify( success=False, msg='Failed to reach server, please check log for details.' ) else: logger.log( 'Switching server prevented, server ID %s does not exist in db' % server_id, 'INFO') except Exception as e: logger.log('Error setting active server to ID %s: %s' % (server_id, e), 'WARNING') return jsonify(success=False) return jsonify(success=True)
def getServers(): global user, servers if not get_setting_value("myPlex_token"): logger.log( 'Plex :: Cannot retrieve servers, need to sign in to plex first', 'ERROR') return False logger.log('Plex :: Getting servers from myPlex servers.xml', 'INFO') try: user = User(get_setting_value('myPlex_username'), get_setting_value('myPlex_password'), get_setting_value('myPlex_token')) servers = user.getServers() except: logger.log( 'Plex :: Failed to retrieve server information from myPlex account', 'ERROR') return False # Storing server information into db try: for server in servers: server['localAddresses'] = server['localAddresses'].split(',')[0] addServer(server['name'], server['address'], server['port'], server['scheme'], server['host'], server['localAddresses'], server['machineIdentifier'], server['createdAt'], server['updatedAt'], server['synced'], server['version'], server['owned'], server['accessToken']) except: logger.log('Plex :: Failed to store server information in database', 'ERROR') return False return servers
def cp_search(message=None): couchpotato = {} params = False profiles = {} try: query = request.args['name'] params = 'q=' + query except: pass if params: try: logger.log('CouchPotato :: Searching for movie: %s' % (query), 'INFO') couchpotato = couchpotato_api('movie.search', params=params) amount = len(couchpotato['movies']) logger.log( 'CouchPotato :: found %i movies for %s' % (amount, query), 'INFO') if couchpotato['success'] and amount != 0: couchpotato = couchpotato['movies'] try: # logger.log('CouchPotato :: Getting quality profiles', 'INFO') profiles = couchpotato_api('profile.list') except Exception as e: log_exception(e) else: return render_template('couchpotato/search.html', error='No movies with "%s" were found' % (query), couchpotato='results') except Exception as e: log_exception(e) couchpotato = None else: logger.log('CouchPotato :: Loading search template', 'DEBUG') couchpotato = None return render_template('couchpotato/search.html', data=couchpotato, couchpotato='results', profiles=profiles, error=message)
def delete_server(server_id=None): """ Deletes a server. """ try: xbmc_server = XbmcServer.query.get(server_id) db_session.delete(xbmc_server) db_session.commit() # Remove the server's cache label = xbmc_server.label recent_cache = [ label + '_episodes', label + '_movies', label + '_albums' ] try: for entry in recent_cache: recent_db = RecentlyAdded.query.filter( RecentlyAdded.name == entry).first() if recent_db: db_session.delete(recent_db) db_session.commit() except: logger.log('Failed to remove servers database cache', 'WARNING') image_dir = os.path.join(maraschino.DATA_DIR, 'cache', 'xbmc', xbmc_server.label) if os.path.isdir(image_dir): import shutil try: shutil.rmtree(image_dir) except: logger.log('Failed to remove servers image cache', 'WARNING') return render_template( 'includes/servers.html', servers=XbmcServer.query.order_by(XbmcServer.position), ) except: logger.log('Error deleting server ID %s' % server_id, 'WARNING') return jsonify({'status': 'error'})
def xhr_headphones_album_status(albumid, status, mobile=False): if status == 'wanted': logger.log('HEADPHONES :: Marking album as wanted', 'INFO') command = 'queueAlbum&id=%s' % albumid if status == 'wanted_new': logger.log('HEADPHONES :: Marking album as wanted (new)', 'INFO') command = 'queueAlbum&new=True&id=%s' % albumid if status == 'skipped': logger.log('HEADPHONES :: Marking album as skipped', 'INFO') command = 'unqueueAlbum&id=%s' % albumid try: Thread(target=headphones_api, args=(command, False)).start() except Exception as e: if mobile: headphones_exception(e) return jsonify(error='failed') return headphones_exception(e) return jsonify(status='successful')
def add_edit_newznab(): name = request.form['name'] url = request.form['url'] apikey = request.form['apikey'] if url.endswith('/'): url = url[:-1] if not name: return jsonify(error=True) if not apikey: return jsonify(error=True) if not url: return jsonify(error=True) if 'newznab_id' in request.form: logger.log('SEARCH :: Editing Newznab site %s' % request.form['newznab_id'], 'INFO') newznab = NewznabSite.query.filter(NewznabSite.id == request.form['newznab_id']).first() newznab.name = name newznab.url = url newznab.apikey = apikey else: logger.log('SEARCH :: Adding new Newznab site', 'INFO') newznab = NewznabSite( name=name, url=url, apikey=apikey ) try: db_session.add(newznab) db_session.commit() except Exception as e: logger.log(e, 'DEBUG') return jsonify(error=True) return xhr_search()
def cp_get_movie(id): """ Retrieve movie from CP ---- Params ----- id int (comma separated) The id of the movie """ try: logger.log('CouchPotato :: Retrieving movie info', 'INFO') result = couchpotato_api('movie.get', 'id=%s' % id) try: logger.log('CouchPotato :: Getting quality profiles', 'INFO') profiles = couchpotato_api('profile.list') except Exception as e: log_exception(e) logger.log('CouchPotato :: Retrieving movie info (DONE)', 'INFO') return render_template('couchpotato/info.html', couchpotato=result, profiles=profiles, ) except Exception as e: log_exception(e) return jsonify({'success': False})
def xhr_couchpotato(status='active'): status_string = 'status=%s' % status template = 'couchpotato.html' if status is not 'active': template = 'couchpotato/all.html' try: logger.log('CouchPotato :: Fetching "%s movies" list' % status, 'INFO') couchpotato = couchpotato_api('movie.list', params=status_string) except Exception as e: log_exception(e) couchpotato = None logger.log('CouchPotato :: Fetching "%s movies" list (DONE)' % status, 'INFO') if status == 'wanted' and not type(couchpotato) is list: logger.log('CouchPotato :: Wanted movies list is empty', 'INFO') return cp_search('There are no movies in your wanted list.') return render_template(template, url=couchpotato_url(), couchpotato=couchpotato, compact_view=get_setting_value('couchpotato_compact') == '1', )
def xhr_couchpotato(status='active'): profiles = {} status_string = 'status=%s' % status template = 'couchpotato.html' if status is not 'active': template = 'couchpotato/all.html' try: logger.log('CouchPotato :: Fetching "%s movies" list' % status, 'INFO') couchpotato = couchpotato_api('movie.list', params=status_string) except Exception as e: log_exception(e) couchpotato = None logger.log('CouchPotato :: Fetching "%s movies" list (DONE)' % status, 'INFO') if status == 'wanted' and not type(couchpotato) is list: logger.log('CouchPotato :: Wanted movies list is empty', 'INFO') return cp_search('There are no movies in your wanted list.') profiles = couchpotato_api('profile.list') for movie in couchpotato['movies']: for profile in profiles['list']: if profile['id'] == movie['profile_id']: movie['profile_label'] = profile['label'] return render_template( template, url=couchpotato_url(), app_link=couchpotato_url_no_api(), couchpotato=couchpotato, profiles=profiles, compact_view=get_setting_value('couchpotato_compact') == '1', )
def xhr_move_playlist_item(playlistid, position1, direction): logger.log('CONTROLS :: Moving playlist item %s' % direction, 'INFO') xbmc = jsonrpclib.Server(server_api_address()) if direction == 'up': if position1 != 0: position2 = position1 - 1 else: logger.log( 'CONTROLS :: Playlist item is already at first position', 'INFO') return jsonify({'success': True}) else: position2 = position1 + 1 try: xbmc.Playlist.Swap(playlistid=playlistid, position1=position1, position2=position2) return jsonify({'success': True}) except: logger.log('CONTROLS :: %s' % xbmc_error, 'ERROR') return jsonify({'failed': True})
def checkGithub(): """Check github repo for updates""" logger.log('UPDATER :: Checking for updates', 'INFO') try: maraschino.LATEST_COMMIT = latestCommit() if maraschino.FIRST_RUN: maraschino.CURRENT_COMMIT = maraschino.LATEST_COMMIT writeVersion(maraschino.CURRENT_COMMIT) except: logger.log('UPDATER :: Could not get latest commit from github', 'WARNING') if maraschino.CURRENT_COMMIT: try: maraschino.COMMITS_BEHIND = commitsBehind() except: logger.log('UPDATER :: Could not get commits behind from github', 'WARNING') if maraschino.COMMITS_BEHIND >= 1: logger.log( 'UPDATER :: Update available, you are %i commits behind' % maraschino.COMMITS_BEHIND, 'INFO') maraschino.COMMITS_COMPARE_URL = 'https://github.com/%s/maraschino/compare/%s...%s' % ( user, maraschino.CURRENT_COMMIT, maraschino.LATEST_COMMIT) elif maraschino.COMMITS_BEHIND == 0: logger.log('UPDATER :: Up to date', 'INFO') elif maraschino.COMMITS_BEHIND == -1: logger.log('UPDATER :: Unknown version. Please run the updater', 'INFO') else: logger.log('UPDATER :: Unknown version. Please run the updater', 'INFO') return maraschino.COMMITS_BEHIND
def Update(): """Update maraschino installation""" if maraschino.USE_GIT: update = gitUpdate() if update == 'complete': return True else: logger.log('Git update failed, attempting tarball update', 'INFO') tar_file = joinRundir('maraschino.tar.gz') update_folder = joinRundir('maraschino-update') # Download repo try: logger.log('UPDATER :: Downloading update file to %s' % tar_file, 'DEBUG') url = urllib2.urlopen('https://github.com/%s/maraschino/tarball/%s' % (user, branch)) f = open(tar_file, 'wb') f.write(url.read()) f.close() except: logger.log('UPDATER :: Failed to download update file', 'WARNING') RemoveUpdateFiles() return False # Write new hash to file try: logger.log('UPDATER :: Writing new hash to %s' % version_file, 'DEBUG') writeVersion(maraschino.LATEST_COMMIT) except: logger.log('UPDATER :: Faied to write new hash to version file', 'WARNING') RemoveUpdateFiles() return False # Extract to temp folder try: logger.log('UPDATER :: Extracting %s' % tar_file, 'DEBUG') tar = tarfile.open(tar_file) tar.extractall(update_folder) tar.close() except: logger.log('Failed to extract update file', 'WARNING') RemoveUpdateFiles() return False # Overwrite old files with new ones root_src_dir = os.path.join( update_folder, '%s-maraschino-%s' % (user, maraschino.LATEST_COMMIT[:7])) try: logger.log('UPDATER :: Overwriting old files', 'DEBUG') for src_dir, dirs, files in os.walk(root_src_dir): dst_dir = src_dir.replace(root_src_dir, RUNDIR) if not os.path.exists(dst_dir): os.mkdir(dst_dir) for file_ in files: src_file = os.path.join(src_dir, file_) dst_file = os.path.join(dst_dir, file_) if os.path.exists(dst_file): os.remove(dst_file) shutil.move(src_file, dst_dir) except: logger.log('UPDATER :: Failed to overwrite old files', 'WARNING') RemoveUpdateFiles() return False # Clean up RemoveUpdateFiles() maraschino.CURRENT_COMMIT = maraschino.LATEST_COMMIT maraschino.COMMITS_BEHIND = 0 return True