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)