def get_update(): instance = int(request.args.get("instance")) if instance == 1: return to_JSON( UpdateAvailable(Updater().check_version(), Updater().last_version)) else: result = APIController().slave_request(instance, "get_last_version", 10) if result is None: return to_JSON(UpdateAvailable(False, "")) return to_JSON(UpdateAvailable(result[0], result[1]))
def get_action_history(): topic = request.args.get("topic") start_time = int(request.args.get("start")) end_time = int(request.args.get("end")) return to_JSON(Database().get_action_history(topic, start_time, end_time))
def get_toon_status(): status = ToonManager().get_status() result = ThermostatInfo(status.active_state, status.current_displayed_temperature, status.current_set_point) return to_JSON(result)
def search(): terms = request.args.get('keywords') category = request.args.get('category') return to_JSON( TorrentController.get_torrents(TorrentController.base_url + "/category-search/" + terms + "/" + category + "/1/"))
def get_devices(): result = TradfriManager().get_devices() if len(result) == 0: result = TradfriController.create_test_data() return to_JSON(result)
def get_shows(): page = int(request.args.get('page')) order_by = request.args.get('orderby') keywords = request.args.get('keywords') include_previous_pages = request.args.get('page') == "true" search_string = "" if keywords: search_string = "&keywords=" + urllib.parse.quote(keywords) if include_previous_pages: data = [] current_page = 0 while current_page != page: current_page += 1 data += ShowController.request_shows( ShowController.shows_api_path + "shows/" + str(current_page) + "?sort=" + urllib.parse.quote(order_by) + search_string) else: data = ShowController.request_shows(ShowController.shows_api_path + "shows/" + str(page) + "?sort=" + urllib.parse.quote(order_by) + search_string) return to_JSON(data).encode()
def get_electricity_details(): start_hours = request.args.get('startHours') end_hours = request.args.get('endHours') stats = ToonManager().get_electricity_stats(start_hours + " hours ago", end_hours + " hours ago") return to_JSON(stats)
def get_directory(): path = request.args.get('path') if sys.platform == "win32": path = "C:" + path directory = HDController.get_directory_internal(path) return to_JSON(directory).encode('utf8')
def _send_request(self, topic, data, room): Logger().write(LogVerbosity.Debug, "Sending request: " + topic + ", data: " + str(data)) request_id = APIController().next_id() request_message = Request(request_id, topic, data, room, self._complete_request) self.requests.append(request_message) data = to_JSON(data) self.emit("request", (request_id, topic, data), room=room) return request_message
def execute_health_test(): Logger().write(LogVerbosity.Info, "System health test") result = HealthTestResult() UtilController.run_endpoint_checks(result) UtilController.run_torrent_check(result) return to_JSON(result)
def get_group_devices(): group_id = int(request.args.get('group_id')) result = TradfriManager().get_devices_in_group(group_id) if len(result) == 0: result = TradfriController.create_test_data() return to_JSON(result)
def get_gas_details(): start_hours = request.args.get('startHours') end_hours = int(request.args.get('endHours')) if end_hours == 0: end_hours = 0.001 stats = ToonManager().get_gas_stats(start_hours + " hours ago", str(end_hours) + " hours ago", "hours") return to_JSON(stats)
def top(): category = request.args.get('category') if category == "TV": category = "television" elif category == "Movies": category = "movies" return to_JSON( TorrentController.get_torrents(TorrentController.base_url + "/top-100-" + category))
def refresh(): client_id = request.headers.get('Client-ID', None) client_key = APIController.get_salted(client_id) client_known = Database().client_known(client_key) ip_addr = request.headers.get('HTTP_X_FORWARDED_FOR', None) or request.remote_addr user_agent = request.user_agent.string if not client_known: Logger().write(LogVerbosity.Info, str(client_id) + " failed to refresh") Database().add_login_attempt(client_key, ip_addr, user_agent, "Refresh") return to_JSON(AuthResult(False, None)), 401 session_key = AuthController.generate_session_key() Database().refresh_session_key(client_key, session_key, ip_addr, user_agent) Logger().write(LogVerbosity.Debug, str(client_id) + " successfully refreshed") return to_JSON(AuthResult(True, session_key)), 200
def get_toon_details(): status = ToonManager().get_status() states = ToonManager().get_states() result = ThermostatDetails( status.active_state, status.current_displayed_temperature, status.current_modulation_level, status.current_set_point, status.next_program, status.next_set_point, status.next_state, status.next_time, status.program_state, status.real_set_point, [ ThermostatState(x.name, x.id, x.temperature, x.dhw) for x in states if x.id != 4 ]) return to_JSON(result)
def on_subscribe(topic): authenticated = [ x for x in UIWebsocketController.clients if x.sid == request.sid ][0].authenticated if not authenticated: Logger().write(LogVerbosity.Info, "Unauthenticated socket request subscribing") return Logger().write(LogVerbosity.Info, "UI client subscribing to " + topic) join_room(topic) if topic in APIController.last_data: emit("update", (topic, to_JSON(APIController.last_data[topic])), namespace="/UI", room=request.sid)
def on_get_current_requests(): authenticated = [ x for x in UIWebsocketController.clients if x.sid == request.sid ][0].authenticated if not authenticated: Logger().write( LogVerbosity.Info, "Unauthenticated socket request for current requests") return for client_request in APIController().ui_websocket_controller.requests: socketio.emit("request", (client_request.request_id, client_request.topic, to_JSON(client_request.data)), namespace="/UI", room=request.sid)
def login(): client_id = request.headers.get('Client-ID', None) p = request.args.get('p') ip_addr = request.headers.get('HTTP_X_FORWARDED_FOR', None) or request.remote_addr user_agent = request.user_agent.string success, key = AuthController.validate(client_id, p, ip_addr, user_agent) Logger().write(LogVerbosity.Info, str(client_id) + " log on result: " + str(success)) status = 200 if not success: Database().add_login_attempt(APIController.get_salted(client_id), ip_addr, user_agent, "Login") status = 401 return to_JSON(AuthResult(success, key)), status
def youtube_search(): YouTubeController.check_token() keywords = urllib.parse.unquote(request.args.get('keywords')) page_token = request.args.get('token', None) type = request.args.get('type').lower() Logger().write( LogVerbosity.Debug, "Searching youtube for {} of type {}".format(keywords, type)) search_data = YouTubeController.api.get('search', q=keywords, type=type, maxResults=50, pageToken=page_token) result = [] iso_unix_time = dateutil.parser.isoparse("1970-01-01T00:00:00.000Z") for search_result in search_data['items']: if type == "video": upload_time = search_result['snippet']['publishedAt'] upload_time = dateutil.parser.isoparse(upload_time) upload_time = (upload_time - iso_unix_time) / timedelta(milliseconds=1) result.append( YouTubeMedia( search_result['id']['videoId'], search_result['snippet']['thumbnails']['medium'] ['url'], search_result['snippet']['title'], upload_time, search_result['snippet']['channelId'], search_result['snippet']['channelTitle'])) else: result.append( BaseMedia( search_result['id']['channelId'], search_result['snippet']['thumbnails']['medium'] ['url'], search_result['snippet']['title'])) token = None if 'nextPageToken' in search_data: token = search_data['nextPageToken'] return to_JSON(SearchResult(result, token))
def youtube_channel(): YouTubeController.check_token() id = request.args.get('id') page = request.args.get('page') token = request.args.get('token', None) channel_data = YouTubeController.api.get( 'channels', id=id, part="contentDetails,statistics,snippet") channel = channel_data['items'][0] result = YouTubeChannel( id, channel['snippet']['title'], channel['snippet']['thumbnails']['medium']['url'], channel['snippet']['description'], channel['statistics']['viewCount'], channel['statistics']['subscriberCount'], channel['statistics']['videoCount']) result.favorite = id in [x.id for x in Database().get_favorites()] play_list = channel['contentDetails']['relatedPlaylists']['uploads'] uploads = YouTubeController.api.get('playlistItems', playlistId=play_list, maxResults=50, page=page, pageToken=token, part="snippet") iso_unix_time = dateutil.parser.isoparse("1970-01-01T00:00:00.000Z") for item in uploads['items']: upload_time = item['snippet']['publishedAt'] upload_time = dateutil.parser.isoparse(upload_time) upload_time = (upload_time - iso_unix_time) / timedelta(milliseconds=1) result.uploads.append( YouTubeMedia(item['snippet']['resourceId']['videoId'], item['snippet']['thumbnails']['medium']['url'], item['snippet']['title'], upload_time, item['snippet']['channelId'], item['snippet']['channelTitle'])) if 'nextPageToken' in uploads: result.token = uploads['nextPageToken'] return to_JSON(result)
def youtube_video(): YouTubeController.check_token() id = request.args.get('id') video_data = YouTubeController.api.get( 'videos', id=id, part="contentDetails,statistics,snippet") video = video_data['items'][0] data = YouTubeVideo( id, "https://youtube.com/watch?v=" + id, video['snippet']['thumbnails']['medium']['url'], video['snippet']['title'], video['snippet']['publishedAt'], video['snippet']['channelId'], video['snippet']['channelTitle'], video['snippet']['description'], video['contentDetails']['duration'], video['statistics']['viewCount'], video['statistics']['likeCount'], video['statistics']['dislikeCount']) seen = Database().get_history_for_url(data.url) data.seen = len(seen) > 0 if len(seen) > 0: seen = seen[-1] data.played_for = seen.played_for return to_JSON(data)
def get_client(): Logger().write(LogVerbosity.Debug, "Getting client") return to_JSON(Database().get_client_access(request.args.get('id')))
def get_clients(): Logger().write(LogVerbosity.Debug, "Getting clients") return to_JSON(Database().get_clients())
def get_history(): Logger().write(LogVerbosity.Debug, "Getting history") return to_JSON(Database().get_history())
def get_history_for_url(): url = request.args.get('url') Logger().write(LogVerbosity.Debug, "Getting history") return to_JSON(Database().get_history_for_url( urllib.parse.unquote(url)))
def broadcast(topic, data): APIController.last_data[topic] = data Logger().write(LogVerbosity.All, "Sending update: " + topic) socketio.emit("update", (topic, to_JSON(data)), namespace="/UI", room=topic)
def youtube_main(): YouTubeController.check_token() page = int(request.args.get('page', 1)) if len(YouTubeController.subscriptions) == 0: YouTubeController.__request_subscriptions(None) before_date = datetime.utcnow() - timedelta(days=3 * (page - 1)) after_date = datetime.utcnow() - timedelta(days=3 * page) if YouTubeController.max_activity_range is not None and before_date < YouTubeController.max_activity_range \ and before_date > YouTubeController.min_activity_range: if after_date < YouTubeController.min_activity_range: before_date = YouTubeController.min_activity_range else: after_date = YouTubeController.max_activity_range if YouTubeController.max_activity_range is not None and after_date > YouTubeController.min_activity_range \ and after_date < YouTubeController.max_activity_range: if before_date > YouTubeController.max_activity_range: after_date = YouTubeController.max_activity_range else: before_date = YouTubeController.min_activity_range if YouTubeController.max_activity_range is None: YouTubeController.max_activity_range = before_date YouTubeController.min_activity_range = after_date else: YouTubeController.max_activity_range = max( before_date, YouTubeController.max_activity_range) YouTubeController.min_activity_range = min( after_date, YouTubeController.min_activity_range) if before_date - after_date > timedelta(minutes=15): Logger().write( LogVerbosity.Debug, "Requesting activity from {} to {}".format( after_date, before_date)) iso_unix_time = dateutil.parser.isoparse( "1970-01-01T00:00:00.000Z") for sub in YouTubeController.subscriptions: result = YouTubeController.api.get( 'activities', maxResults=50, channelId=sub.channelId, publishedAfter=after_date.isoformat() + "Z", publishedBefore=before_date.isoformat() + "Z", part="contentDetails,snippet") for act in [ x for x in result['items'] if x['snippet']['type'] == 'upload' ]: upload_time = act['snippet']['publishedAt'] upload_time = dateutil.parser.isoparse(upload_time) upload_time = (upload_time - iso_unix_time) / timedelta(milliseconds=1) sub.uploads.append( YouTubeMedia( act['contentDetails']['upload']['videoId'], act['snippet']['thumbnails']['medium']['url'], act['snippet']['title'], upload_time, sub.channelId, sub.title)) return to_JSON(YouTubeController.subscriptions)
def get_favorites(): Logger().write(LogVerbosity.Debug, "Getting favorites") return to_JSON(Database().get_favorites())
def get_unfinished_items(): Logger().write(LogVerbosity.Debug, "Getting unfinished items") return to_JSON(Database().get_watching_items())
def get_log_files(): log_files = Logger.get_log_files() return to_JSON([(name, path, write_size(size)) for name, path, size in log_files])