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