def do_button_release(self): # Ensure that an entry is being created. if self.current_tagged_entry is None: return tagged_entry_to_create = self.current_tagged_entry if tagged_entry_to_create.start == tagged_entry_to_create.stop: self.current_tagged_entry = None return # Choose category with database_helper.create_connection() as conn: category_repository = CategoryRepository() categories = category_repository.get_all(conn=conn) dialog = CategoryChoiceDialog(window=self.parent, categories=categories, tagged_entry=tagged_entry_to_create) r = dialog.run() self.current_tagged_entry = None chosen_category_name = dialog.get_chosen_category_value() dialog.destroy() if r == Gtk.ResponseType.OK: # Set chosen category chosen_category = [ c for c in categories if c.name.lower() == chosen_category_name.lower() ] if len(chosen_category) == 1: chosen_category = chosen_category[0] else: new_category = entity.Category(name=chosen_category_name) with database_helper.create_connection() as conn: new_category.db_id = category_repository.insert( conn=conn, category=new_category) chosen_category = new_category tagged_entry_to_create.category = chosen_category self.emit("tagged-entry-created", tagged_entry_to_create) self.queue_draw()
def register_activity_entry(idle_period: int, locked_state: bool, datetime_now: datetime.datetime): configuration = configuration_helper.get_configuration() activity_entry_repository = ActivityEntryRepository() was_active = not locked_state and idle_period < configuration.inactive_after_idle_seconds with database_helper.create_connection() as db_connection: last_activity_entry = activity_entry_repository.get_latest_entry( conn=db_connection) if last_activity_entry is None: logging.info("No existing activity entry, creating a new one") new_update = datetime_now + datetime.timedelta(seconds=1) activity_entry = ActivityEntry(start=datetime_now, stop=new_update, active=was_active) activity_entry_repository.insert(conn=db_connection, activity_entry=activity_entry) else: logging.debug("Last logged stop:", last_activity_entry.stop) max_delta_seconds = configuration.seconds_before_new_entry max_delta_period = datetime.timedelta(seconds=max_delta_seconds) old_end = last_activity_entry.stop if max_delta_period < datetime_now - old_end: logging.info("Too long since last update. Create a new entry.") new_update = datetime_now + datetime.timedelta(seconds=1) activity_entry = ActivityEntry(start=datetime_now, stop=new_update, active=was_active) activity_entry_repository.insert(db_connection, activity_entry) elif last_activity_entry.active == was_active: logging.info( "Still same activity level. Update existing entry") db_connection.execute( "UPDATE activity_entry SET ae_last_update=:new_update WHERE ae_id=:id", { "id": last_activity_entry.db_id, "new_update": datetime_helper.datetime_to_timestamp(datetime_now) }) else: logging.info( "Not the same activity level. Insert new activity entry") activity_entry = ActivityEntry(start=last_activity_entry.stop, stop=datetime_now, active=was_active) activity_entry_repository.insert(db_connection, activity_entry) db_connection.commit()
def register_logged_entry(application_window: ApplicationWindow, datetime_now: datetime.datetime): logged_entry_repository = LoggedEntryRepository() with database_helper.create_connection() as db_connection: last_logged_entry = logged_entry_repository.get_latest_entry( conn=db_connection) if last_logged_entry is None: logging.info("No existing logged entry, creating a new one") new_update = datetime_now + datetime.timedelta(seconds=1) logged_entry = LoggedEntry(start=datetime_now, stop=new_update, application_window=application_window) logged_entry_repository.insert(conn=db_connection, logged_entry=logged_entry) else: logging.debug("Last logged stop:", last_logged_entry.stop) configuration = configuration_helper.get_configuration() max_delta_seconds = configuration.seconds_before_new_entry max_delta_period = datetime.timedelta(seconds=max_delta_seconds) old_end = last_logged_entry.stop if max_delta_period < datetime_now - old_end: logging.info("Too long since last update. Create a new entry.") start_datetime = datetime_now + datetime.timedelta(seconds=-1) logged_entry = LoggedEntry( start=start_datetime, stop=datetime_now, application_window=application_window) logged_entry_repository.insert(db_connection, logged_entry) elif last_logged_entry.application_window.db_id == application_window.db_id: logging.info("Still same window. Update existing logged entry") db_connection.execute( "UPDATE logged_entry SET le_last_update=:new_update WHERE le_id=:id", { "id": last_logged_entry.db_id, "new_update": datetime_helper.datetime_to_timestamp(datetime_now) }) else: logging.info("Not the same window. Insert new logged entry") logged_entry = LoggedEntry( start=last_logged_entry.stop, stop=datetime_now, application_window=application_window) logged_entry_repository.insert(db_connection, logged_entry) db_connection.commit()
def _reload_logged_entries_from_date(self): with database_helper.create_connection() as db_connection: logged_entry_repository = LoggedEntryRepository() tagged_entry_repository = TaggedEntryRepository() activity_entry_repository = ActivityEntryRepository() logged_entries = logged_entry_repository.get_all_by_date( db_connection, self._current_date) tagged_entries = tagged_entry_repository.get_all_by_date( db_connection, self._current_date) activity_entries = activity_entry_repository.get_all_by_date( db_connection, self._current_date) self.timeline_canvas.set_entries(self._current_date, logged_entries, tagged_entries, activity_entries) self.timeline_minimap.set_entries(self._current_date, logged_entries, tagged_entries) self.logged_entries_list_store.clear() for le in logged_entries: self.logged_entries_list_store.append([ datetime_helper.to_time_str(le.start), datetime_helper.to_time_str(le.stop), datetime_helper.to_duration_str(le.duration), le.application_window.application.name, le.application_window.title ]) self.logged_entries_tree_view.columns_autosize() self.tagged_entries_list_store.clear() total_duration = datetime.timedelta() for te_category, te_group in groupby(sorted( tagged_entries, key=lambda x: x.category.db_id), key=lambda x: x.category.name): te_list = list(te_group) duration = sum([te.duration for te in te_list], start=datetime.timedelta()) total_duration += duration category = te_list[0].category expanded_url = link_helper.expand_tags(url=category.url, dt=self._current_date) self.tagged_entries_list_store.append([ datetime_helper.to_duration_str(duration), te_category, expanded_url ]) self.tagged_entries_tree_view.columns_autosize() self.tagged_time_label.set_label( datetime_helper.to_duration_str(total_duration))
def insert_if_needed_and_get_application_path( application_path: str) -> ApplicationPath: with database_helper.create_connection() as db_connection: application_path_repository = ApplicationPathRepository() ap = application_path_repository.get_by_path( conn=db_connection, path=str(application_path)) # We couldn't find an existing entry in the database. Insert a new one. if ap is None: logging.info("Adding new application path") application_path_id = application_path_repository.insert( db_connection, str(application_path)) else: application_path_id = ap.db_id application_path = application_path_repository.get( conn=db_connection, db_id=application_path_id) return application_path
def insert_if_needed_and_get_application_window( application: Application, window_title: str) -> ApplicationWindow: with database_helper.create_connection() as db_connection: application_window_repository = ApplicationWindowRepository() application_window = application_window_repository.get_by_title_and_application_id( conn=db_connection, title=window_title, application_id=application.db_id) # We couldn't find an existing entry in the database. Insert a new one. if application_window is None: logging.info("Adding new application window") application_window = ApplicationWindow(title=window_title, application=application) db_id = application_window_repository.insert( conn=db_connection, application_window=application_window) application_window.db_id = db_id logging.debug(f"application_window_id = {application_window.db_id}") return application_window
def insert_if_needed_and_get_application( application_name: str, application_path: ApplicationPath) -> Application: with database_helper.create_connection() as db_connection: application_repository = ApplicationRepository() application = application_repository.get_by_name_and_path_id( conn=db_connection, name=application_name, path_id=application_path.db_id) # We couldn't find an existing entry in the database. Insert a new one. if application is None: logging.info("Adding new application") application_id = application_repository.insert( conn=db_connection, name=application_name, application_path=application_path) application = application_repository.get(db_connection, application_id) logging.debug(f"application_id = {application.db_id}") return application
def get_total_category_tagged_time(category_name: str) -> int: with database_helper.create_connection() as conn: total_time = tagged_entry_repository.total_time_by_category( conn=conn, category_name=category_name) return total_time
def _do_tagged_entry_deleted(self, _, te: TaggedEntry): tagged_entry_repository = TaggedEntryRepository() with database_helper.create_connection() as conn: tagged_entry_repository.delete(conn=conn, db_id=te.db_id) self._reload_logged_entries_from_date()
def _do_tagged_entry_created(self, _, te: TaggedEntry): tagged_entry_repository = TaggedEntryRepository() with database_helper.create_connection() as conn: tagged_entry_repository.insert(conn=conn, tagged_entry=te) self._reload_logged_entries_from_date()