Update task_operations.py

task_operations.py

@@ -1,95 +1,88 @@
-import os
+# components/task_operations.py
+
+import sqlite3
 import pandas as pd
 from datetime import datetime
 import streamlit as st
-import uuid  # For generating unique IDs
-import shutil  # To create a backup of the file
 
 class TaskManager:
-    TASKS_FILE = "tasks.csv"
-    BACKUP_FILE = "tasks_backup.csv"
+    DB_FILE = "tasks.db"
     CATEGORIES = ['Learning', 'Gym', 'Personal', 'Family', 'Work', 'Prayer']
 
     def __init__(self):
-        if 'tasks' not in st.session_state:
-            st.session_state.tasks = self.load_tasks()
-
-    def backup_csv(self):
-        """Create a backup of the current tasks file."""
-        if os.path.exists(self.TASKS_FILE):
-            shutil.copy(self.TASKS_FILE, self.BACKUP_FILE)
+        self.conn = sqlite3.connect(self.DB_FILE)
+        self.create_table()
 
-    def restore_from_backup(self):
-        """Restore tasks from backup if needed."""
-        if os.path.exists(self.BACKUP_FILE):
-            shutil.copy(self.BACKUP_FILE, self.TASKS_FILE)
+    def create_table(self):
+        # Create tasks table with unique id
+        query = """
+        CREATE TABLE IF NOT EXISTS tasks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            task_name TEXT,
+            task_time TEXT,
+            task_duration_hours INTEGER,
+            task_duration_minutes INTEGER,
+            category TEXT
+        );
+        """
+        self.conn.execute(query)
+        self.conn.commit()
 
     def load_tasks(self):
-        # Check if the file exists and has data
-        if os.path.exists(self.TASKS_FILE) and os.path.getsize(self.TASKS_FILE) > 0:
-            try:
-                return pd.read_csv(self.TASKS_FILE, parse_dates=['Task Time']).to_dict(orient='records')
-            except pd.errors.EmptyDataError:
-                return []  # Return empty list if CSV is empty
+        # Load tasks from the database
+        query = "SELECT * FROM tasks;"
+        df = pd.read_sql_query(query, self.conn)
+        
+        if not df.empty:
+            # Ensure 'Task Time' is in datetime format and id is an integer
+            df['Task Time'] = pd.to_datetime(df['task_time'])  # Convert task_time to datetime
+            df['id'] = df['id'].astype(int)  # Ensure id is an integer
+            df = df.rename(columns={
+                'task_name': 'Task Name', 
+                'task_time': 'Task Time',
+                'task_duration_hours': 'Task Duration (hours)',
+                'task_duration_minutes': 'Task Duration (minutes)', 
+                'category': 'Category', 
+                'id': 'Task ID'  # Rename id to 'Task ID'
+            })
+            return df.to_dict(orient='records')
         else:
-            # If file doesn't exist, initialize it with an empty DataFrame and correct columns
-            df = pd.DataFrame(columns=["Task ID", "Task Name", "Task Time", "Task Duration (hours)", "Task Duration (minutes)", "Category"])
-            df.to_csv(self.TASKS_FILE, index=False)
-            return []  # Return an empty list to the session state
+            return []
 
-    def save_tasks(self, tasks):
-        """Save tasks to the CSV file after making a backup."""
-        if tasks:  # Only save if tasks are not empty
-            # Backup the current file before saving
-            self.backup_csv()
-            df = pd.DataFrame(tasks)
-            df.to_csv(self.TASKS_FILE, index=False)
-        else:
-            # Prevent overwriting the file with an empty DataFrame
-            st.warning("No tasks to save. File write skipped to prevent data loss.")
+    def save_task(self, task):
+        # Save task into the database
+        query = """
+        INSERT INTO tasks (task_name, task_time, task_duration_hours, task_duration_minutes, category)
+        VALUES (?, ?, ?, ?, ?);
+        """
+        self.conn.execute(query, (task['Task Name'], task['Task Time'], task['Task Duration (hours)'], 
+                                  task['Task Duration (minutes)'], task['Category']))
+        self.conn.commit()
 
     def add_task(self, task_name, task_time, task_duration_hours, task_duration_minutes, task_category):
-        # Ensure valid task details are being added
-        if task_name and task_category:
-            task_time_full = datetime.combine(datetime.today(), task_time)
-            task_id = str(uuid.uuid4())  # Generate a unique ID using uuid4
-            task_entry = {
-                "Task ID": task_id,
-                "Task Name": task_name,
-                "Task Time": task_time_full,
-                "Task Duration (hours)": int(task_duration_hours),
-                "Task Duration (minutes)": int(task_duration_minutes),
-                "Category": task_category
-            }
-            st.session_state.tasks.append(task_entry)
-            self.save_tasks(st.session_state.tasks)
-            st.success(f"Task '{task_name}' added successfully!")
-            # Reload tasks to ensure consistency
-            st.session_state.tasks = self.load_tasks()
-        else:
-            st.error("Task name and category are required.")
+        task_time_full = datetime.combine(datetime.today(), task_time)
+        task_entry = {
+            "Task Name": task_name,
+            "Task Time": task_time_full,
+            "Task Duration (hours)": int(task_duration_hours),
+            "Task Duration (minutes)": int(task_duration_minutes),
+            "Category": task_category
+        }
+        self.save_task(task_entry)
+        st.session_state.tasks.append(task_entry)
 
     def delete_task_by_id(self, task_id):
-        task_found = False
-        for index, task in enumerate(st.session_state.tasks):
-            if task['Task ID'] == task_id:
-                st.session_state.tasks.pop(index)
-                task_found = True
-                break
-        if task_found:
-            self.save_tasks(st.session_state.tasks)
-            st.success(f"Task with ID '{task_id}' deleted.")
-            # Reload tasks to ensure consistency
-            st.session_state.tasks = self.load_tasks()
-        else:
-            st.error(f"Task with ID '{task_id}' not found.")
+        # Delete task by its ID
+        query = "DELETE FROM tasks WHERE id = ?;"
+        self.conn.execute(query, (task_id,))
+        self.conn.commit()
+        return True
 
     def generate_report(self, timeframe):
-        df = pd.DataFrame(st.session_state.tasks)
+        df = pd.DataFrame(self.load_tasks())
         if df.empty:
-            return pd.DataFrame()  # Return empty DataFrame if no tasks are present
-        
-        # Ensure the 'Task Time' is in datetime format
+            return pd.DataFrame()
+
         df['Task Time'] = pd.to_datetime(df['Task Time'])
 
         if timeframe == 'daily':
@@ -102,7 +95,7 @@ class TaskManager:
         elif timeframe == 'yearly':
             report = df[df['Task Time'].dt.year == pd.Timestamp.today().year]
         else:
-            report = pd.DataFrame()  # Empty DataFrame for unsupported timeframes
+            report = pd.DataFrame()
 
         report['Total Duration'] = report['Task Duration (hours)'] + report['Task Duration (minutes)'] / 60.0
         return report