def get_by_id_internal(show_id):
Logger().write(LogVerbosity.Debug, "Get show by id " + show_id)
response = RequestFactory.make_request(ShowController.shows_api_path +
"show/" + show_id)
data = json.loads(response.decode('utf-8'))
seen_episodes = []
data['favorite'] = False
if not Settings.get_bool("slave"):
seen_episodes = Database().get_history_for_id(show_id)
data['favorite'] = show_id in [
x.id for x in Database().get_favorites()
]
for episode in data['episodes']:
seen = [
x for x in seen_episodes if episode['season'] == x.season
and episode['episode'] == x.episode
]
episode['seen'] = len(seen) != 0
if len(seen) == 0:
continue
seen = seen[-1]
episode['seen'] = True
episode['played_for'] = seen.played_for
episode['length'] = seen.length
return data
def main():
"""The main routine."""
# Create the LED control and flash the white light for 1 second.
# rgbled = RGBLED()
# rgbled.flash_white()
# Init the xbee serial communication and set the module to API mode and as a coordinator.
try:
xbee_serial = XBeeSerial()
except serial.serialutil.SerialException:
print("Serial not found for Arduino, trying Mac port")
xbee_serial = XBeeSerial(port='/dev/cu.usbserial-A603U21W')
# Open a connection to the sqlite DB
database = Database()
while True:
try:
request = xbee_serial.wait_poll_frame()
print(request)
if type(request) is RegistrationRequest:
peripheral_id = database.find_create_peripheral(
request.get_name())
database.add_services_to_peripheral(peripheral_id,
request.get_services())
except KeyboardInterrupt:
break
def update_tracking(self, state):
if self.media_data.type == "Radio":
return
if self.history_id == 0 or state.state != PlayerState.Playing or current_time(
) - self.last_tracking_update < 5000:
return
if state.playing_for > state.length - (
state.length *
0.04) or state.length - state.playing_for < 10000:
if Settings.get_bool("slave"):
SlaveClientController.notify_master("update_watching_item",
self.history_id,
state.length, state.length,
current_time())
else:
Database().update_watching_item(self.history_id, state.length,
state.length, current_time())
else:
if Settings.get_bool("slave"):
SlaveClientController.notify_master("update_watching_item",
self.history_id,
state.playing_for,
state.length,
current_time())
else:
Database().update_watching_item(self.history_id,
state.playing_for,
state.length, current_time())
self.last_tracking_update = current_time()
def _clearSch(self):
"""Clears all events of the time table"""
response = messagebox.askquestion(
"Clear time table",
"Are you sure you want to clear the time table?")
if response == "yes":
Database.reset()
self.frames[TimeTablePage].buildTimeTable()
def __init__(self):
self.git_repo = "https://github.com/jkorf/MediaPi.git"
self.git_branch = "NewUI"
self.base_folder = Settings.get_string("base_folder")
self.update_folder = Settings.get_string("base_folder") + "Updates/"
self.ignore_directories = ("/Solution", "/UI/homebase", "/UI/Web")
self.copied_files = 0
self.last_version = Database().get_stat_string("CurrentGitVersion")
self.last_update = Database().get_stat("LastUpdate")
self.update_state = UpdateState(self.last_version, self.last_update)
def _btnClicked(self):
"""Insert data in database when OK button is clicked"""
# Check if all fields were filled
name = self.nameEntry.get().strip()
start = self.startCombo.get()
end = self.endCombo.get()
day = self.dayCombo.get()
type = self.typeCombo.get()
# Check missing values
if name == "" or start == "" or end == "" or day == "" or type == "":
messagebox.showwarning("Missing fields!",
"Please fill the missing fields!")
return
if type in Constants.TASKS[0:3]:
subject = self.subjectCombo.get()
if subject == "":
messagebox.showwarning("Missing fields!",
"Please fill the missing fields!")
return
else:
subject = None
# Check if starts earlier than end
if Time.TIMELIST.index(start) >= Time.TIMELIST.index(end):
messagebox.showwarning("Time error",
"Make sure that time is correct!")
return
# Check time
started = False
index = 0
for t in Time.HOURS:
# Create an event for each hour
if t[0:5] == start: started = True
if t[8:] == end:
started = False
# Add one last event
if subject == "":
event = Event(name, start, end, day, type)
else:
event = Event(name, start, end, day, type, subject)
Database.insert(day, index, event)
if started:
# Create the Event object
if subject == "":
event = Event(name, start, end, day, type)
else:
event = Event(name, start, end, day, type, subject)
Database.insert(day, index, event)
index += 1
self.destroyFrame()
def _addStudyToSchedule(self, subject, timerangeIndex, day):
"""
Insert an event (study time) to database, given it's data
:param subject: Subject of the event
:param timerangeIndex: Index of Time.HOURS list
:param day: Day of the event
:return: None
"""
event = Event("Study {}".format(subject),
Time.HOURS[timerangeIndex][:5],
Time.HOURS[timerangeIndex][9:], day, "Study", subject)
Database.insert(day, timerangeIndex, event)
def media_selection_required(self, files):
if Settings.get_bool("slave"):
data, = SlaveClientController.request_master(
"get_history_for_url", 5, self.torrent.uri)
if data:
history = [
History(x['id'], x['imdb_id'], x['type'], x['title'],
x['image'], x['watched_at'], x['season'],
x['episode'], x['url'], x['media_file'],
x['played_for'], x['length'])
for x in json.loads(data)
]
else:
history = []
else:
history = Database().get_history_for_url(self.torrent.uri)
for file in files:
seen = [x for x in history if x.media_file == file.path]
file.seen = len(seen) > 0
if file.seen:
seen = seen[-1]
file.played_for = seen.played_for
file.play_length = seen.length
APIController().ui_request("SelectMediaFile", self.set_media_file,
60 * 30, files)
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 remove_favorite_youtube():
youtube_id = request.args.get('id')
Logger().write(LogVerbosity.Info,
"Remove youtube favorite: " + youtube_id)
Database().remove_favorite(youtube_id)
return "OK"
def __init__(self):
self.running = False
self.current_rules = []
self.check_thread = CustomThread(self.check_rules, "Rule checker")
self.load_rules()
enabled = Database().get_stat("rules_enabled")
self.enabled = bool(enabled)
def add_favorite():
show_id = request.args.get('id')
title = urllib.parse.unquote(request.args.get('title'))
image = urllib.parse.unquote(request.args.get('image'))
Logger().write(LogVerbosity.Info, "Add show favorite: " + show_id)
Database().add_favorite(show_id, "Show", title, image)
return "OK"
def collect_raw_data(log_info, api_key, base_url, city_name):
"""
Collect environment variables from specified city based on
openweathermap api.
Args:
---------
log_info: object used to storage log information
api_key: login api key
base_url: url of api
city_name: name of the city
Return:
---------
nothing..
"""
final_url = base_url + "appid=" +\
api_key + "&q=" + city_name
weather_data = requests.get(final_url).json()
cities = []
cities.append(
Cidades(city_name, weather_data['coord']['lat'],
weather_data['coord']['lon']))
# INSERE SOMENTE UMA VEZ: REFATORAR!
db = Database()
# db.insert(cities)
cidades = db.read(Cidades)
# De tempos em tempos, ler os dados e povoar a base (a cada minuto)!
start_time = time.time()
while True:
log_info.warning('Collecting data...')
weather_data = requests.get(final_url).json()
mtr_data = []
mtr_data.append(
Meteorologia(
cidades[0].Id, datetime.now(), weather_data['clouds']['all'],
weather_data['main']['humidity'],
weather_data['main']['pressure'], weather_data['main']['temp'],
weather_data['main']['feels_like'],
weather_data['wind']['deg'], weather_data['wind']['speed']))
db.insert(mtr_data)
time.sleep(60.0 - ((time.time() - start_time) % 60.0))
def add_favorite_youtube():
channel_id = request.args.get('id')
title = urllib.parse.unquote(request.args.get('title'))
image = urllib.parse.unquote(request.args.get('image'))
Logger().write(LogVerbosity.Info,
"Add youtube channel favorite: " + channel_id)
Database().add_favorite(channel_id, "YouTube", title, image)
return "OK"
def validate(client_id, p, ip, user_agent):
if APIController.get_salted(p) == SecureSettings.get_string(
"api_password"):
client_key = APIController.get_salted(client_id)
session_key = AuthController.generate_session_key()
Database().add_client(client_key, session_key, ip, user_agent)
return True, session_key
return False, None
def _getFreeTime(self):
"""
Get available time (free time)
All available time is stored in a list corresponding to it's dictionary key
Blocks of free time are stored in the same subset
Each hour of time is stored in a tuple, containing it's time range index
Example:
{
'Monday': [
[(1, {}), (2, {}), (3, {})],
[12, {}]
]
.....
'Sunday': [
]
}
"""
for day in Time.WEEKDAYS[1:]:
self.freeTime[day] = []
# Group free time that are all together in the same slice
slice = []
for hour in range(len(Time.HOURS)):
data = Database.pick(day, hour)
if hour < len(Time.HOURS) - 1:
nextData = Database.pick(day, hour + 1)
else:
nextData = None
if data == {}:
if nextData == {}:
slice.append((hour, data))
else:
if len(slice) == 0:
self.freeTime[day].append([(hour, data)])
else:
slice.append((hour, data))
self.freeTime[day].append(slice)
slice = []
def save_stats(self):
while True:
if self.changed:
self.changed = False
copy = self.cache.statistics.copy()
Logger().write(LogVerbosity.Debug, "Saving stats")
for key, val in copy.items():
Database().update_stat(key, val)
time.sleep(15)
def buildTimeTable(self):
"""Build time table"""
# Time table layout
self.tableFrame = tk.Frame(self)
today = Time.WEEKDAYS[datetime.datetime.today().weekday() + 1]
# Create the timetable
for d in range(len(Time.WEEKDAYS)):
if Time.WEEKDAYS[d] == today:
tk.Label(self.tableFrame,
text=Time.WEEKDAYS[d],
font=Constants.MEDIUM_FONT,
padx=25,
pady=30,
bg=Constants.TODAY[0],
fg=Constants.TODAY[1]).grid(row=0, column=d)
else:
tk.Label(self.tableFrame,
text=Time.WEEKDAYS[d],
font=Constants.MEDIUM_FONT,
padx=25,
pady=30).grid(row=0, column=d)
if d == 0:
for h in range(len(Time.HOURS)):
tk.Label(self.tableFrame,
text=Time.HOURS[h],
font=Constants.MEDIUM_FONT,
padx=20,
pady=5).grid(row=h + 1, column=d)
else:
for e in range(len(Time.HOURS)):
data = Database.pick(Time.WEEKDAYS[d], e)
self.e = tk.Label(self.tableFrame,
width=14,
height=1,
font=Constants.MEDIUM_FONT,
borderwidth=2,
relief="ridge")
if data != {}:
bg = Constants.GRIDCOLOR[Constants.TASKS.index(
data['type'])][0]
fg = Constants.GRIDCOLOR[Constants.TASKS.index(
data['type'])][1]
self.e['text'] = data['name']
self.e['bg'] = bg
self.e['fg'] = fg
self.e.bind("<Button-1>",
lambda ev: self._eventClicked(ev))
self.e.grid(row=e + 1, column=d)
self.tableFrame.grid(row=1, column=0)
def get_directory_internal(path):
Logger().write(LogVerbosity.Debug, "Getting directory: " + path)
directory = FileStructure(urllib.parse.unquote(path))
history = Database().get_history()
for file in directory.file_names:
hist = [x for x in history if x.url == path + file]
if len(hist) > 0:
directory.files.append(File(file, True, hist[-1].played_for, hist[-1].length))
else:
directory.files.append(File(file, False, 0, 0))
return directory
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 _change(self, newName, absences, failures):
"""
This function changes the event on the database
:return: None
"""
# Create a new Event with the new name
newEvent = Event(newName, self.event['start'], self.event['end'],
self.event['day'], self.event['type'],
self.event['subject'], absences, failures)
# Iterate
started = False
index = 0
for t in Time.HOURS:
# Start counting when start time is detected
if t[0:5] == self.event['start']: started = True
if t[8:] == self.event['end']:
started = False
# One last element
if self.event == Database.pick(self.weekday, index):
Database.edit(self.weekday, index, newEvent)
break
if started:
# Delete and add new Event
if self.event == Database.pick(self.weekday, index):
Database.edit(self.weekday, index, newEvent)
index += 1
self.event['name'] = newName
self.event['absences'] = absences
self.event['failures'] = failures
def _delete(self):
"""Delete the selected Event"""
# Get user's response
response = messagebox.askquestion(
"Delete event", "Are you sure you want to delete this event?")
if response == "yes":
started = False
index = 0
for t in Time.HOURS:
# Start counting when start time is detected
if t[0:5] == self.event['start']: started = True
if t[8:] == self.event['end']:
started = False
# Delete last event
if self.event == Database.pick(self.weekday, index):
Database.delete(self.weekday, index)
break
if started:
# Delete events
if self.event == Database.pick(self.weekday, index):
Database.delete(self.weekday, index)
index += 1
self.destroyFrame()
else:
return
def play_radio():
radio_id = int(request.args.get("id"))
radio = [x for x in Database().get_radios() if x.id == radio_id][0]
instance = int(request.args.get("instance"))
Logger().write(LogVerbosity.Info,
"Play radio " + radio.title + " on " + str(instance))
if instance == 1:
MediaManager().start_radio(radio.title, radio.url)
else:
APIController().slave_command(instance, "media", "start_radio",
radio.title, radio.url)
return "OK"
def on_init(client_id, session_key):
Logger().write(LogVerbosity.Info, "Init UI: " + client_id)
client = [
x for x in UIWebsocketController.clients if x.sid == request.sid
][0]
client_key = APIController.get_salted(client_id)
client.authenticated = Database().check_session_key(
client_key, session_key)
if not client.authenticated:
Logger().write(LogVerbosity.Debug, "UI invalid client/session key")
return client.authenticated
def set_temperature(self, temp, src):
Logger().write(LogVerbosity.Debug, "Set toon temperature: " + str(temp))
for i in range(3):
try:
self.api.thermostat = temp
Logger().write(LogVerbosity.Debug, "Temp set")
Database().add_action_history("temperature", "set", src, temp)
return
except json.decoder.JSONDecodeError as e:
Logger().write(LogVerbosity.Info, "Toon set temp error, try " + str(i + 1))
if i == 2:
Logger().write_error(e, "Toon set temp error")
time.sleep(1)
def on_notify(topic, data):
slave = APIController.slaves.get_slave_by_sid(request.sid)
if slave is None:
Logger().write(LogVerbosity.Debug,
"Slave notification for not initialized slave")
disconnect()
return
data = json.loads(data)
Logger().write(LogVerbosity.Debug,
"Slave notification " + topic + ": " + str(data))
if topic == "update_watching_item":
Database().update_watching_item(*data)
def start_url(self, title, url):
self.stop_play()
VLCPlayer().play(url, 0)
if Settings.get_bool("slave"):
self.history_id, = SlaveClientController.request_master(
"add_watched_url", 5, url, current_time())
else:
self.history_id = Database().add_watched_url(url, current_time())
self.media_data.start_update()
self.media_data.type = "Url"
self.media_data.title = title
self.media_data.stop_update()
TVManager().switch_input_to_pi()
def get_movie_by_id():
movie_id = request.args.get('id')
Logger().write(LogVerbosity.Debug, "Get movie by id " + movie_id)
response = RequestFactory.make_request(MovieController.movies_api_path + "movie/" + movie_id)
data = json.loads(response.decode('utf-8'))
seen = Database().get_history_for_id(movie_id)
data['seen'] = len(seen) > 0
if len(seen) > 0:
seen = seen[-1]
data['played_for'] = seen.played_for
data['length'] = seen.length
return json.dumps(data).encode('utf-8')
def __init__(self, eventCoords, *args, **kwargs):
self.weekday = Time.WEEKDAYS[eventCoords[0]]
self.timeIndex = eventCoords[1] - 1
self.event = Database.pick(self.weekday, self.timeIndex)
tk.Tk.__init__(self, *args, **kwargs)
self.geometry(Constants.POPSIZE)
self.resizable(False, False)
self.title(self.event['name'])
self.protocol("WM_DELETE_WINDOW", self.destroyFrame)
self.container = tk.Frame(self)
self.container.pack(side="top", fill="both", expand=True)
self._build_frame()
def __init__(self):
self.commands = {
"!commands": self.list_commands,
}
self.commandDescriptions = {
"!commands": "Lists all commands",
}
self.database = Database('GroupMe')
self.Lastfm = LastfmCommands()
self.commands.update(self.Lastfm.commands)
self.commandDescriptions.update(self.Lastfm.commandDescriptions)
self.client = Client.from_token(groupyToken)
self.ran_tasks = False
__author__="alfaflight"
__date__ ="$Apr 1, 2016 10:21:35 PM$"
from Database.Database import Database
from Database.Person import Person
Database_test = Database()
Person_test = Person("Hello", "World")
Database_test.addPerson(Person_test)
Person_test = Person("Derrick", "Tseng")
Database_test.addPerson(Person_test)
Database_test.displayDatabase()
def eclipses_add(self, libelle, dateDeb, dateFin, pays, departement, type):
eclipse = Eclipse(libelle, dateDeb, dateFin, pays, departement, type)
db = Database()
db.create(eclipse, Eclipse)
raise cherrypy.HTTPRedirect('/eclipses/')
from datetime import datetime
from Database.Database import Database
from Models.models import *
if __name__ == "__main__":
db = Database()
isOn = True
while(True):
print("Mode console")
print("1 : Créer")
print("2 : Supprimer")
print("3 : Modifier")
print("4 : Quitter")
action = int(input("Sélectionner l'option désirée : "))
if action == 1:
print("Création d'un objet")
print("1 : Evènement")
print("2 : Eruption")
print("3 : Eclipse")
action = int(input("Choisir l'objet à créer : "))
if action == 1:
libelle = input("Libelle : ")
dateDeb = input("Date de début : ")
dateFin = input("Date de fin : ")
pays = input("Pays : ")
departement = input("Département (si France) : ")
evenement = Evenement(libelle,dateDeb,dateFin,pays,departement)
db.create(evenement, Evenement)
if action == 2:
libelle = input("Libelle : ")
def evenements_add(self, libelle, dateDeb, dateFin, pays, departement, type):
evenement = Evenement(libelle, dateDeb, dateFin, pays, departement, type)
db = Database()
db.create(evenement, Evenement)
raise cherrypy.HTTPRedirect('/evenements/')
def eclipses(self):
db = Database()
print("toto")
eclipses = db.retrieve(Eclipse)
print(eclipses)
return _eclipses.render_unicode(eclipses=eclipses)
def evenements(self):
db = Database()
evenements = db.retrieve(Evenement)
return _evenements.render_unicode(evenements=evenements)
def eruptions(self):
db = Database()
eruptions = db.retrieve((Eruption))
return _eruptions.render_unicode(eruptions=eruptions)
def eruptions_add(self, libelle, duree, date, intensite):
eruption = Eruption(libelle, duree, date, intensite)
db = Database()
db.create(eruption, Eruption)
raise cherrypy.HTTPRedirect('/eruptions/')
def eclipses(self):
db = Database()
eclipses = db.retrieve((Eclipse))
return _eclipses.render_unicode(eclipses=eclipses)