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])
