Update app.py

app.py

@@ -1,288 +1,191 @@
 import streamlit as st
 from cryptography.fernet import Fernet
-from datetime import datetime
-import uuid
-import bcrypt
+from datetime import datetime, timedelta
 import sqlite3
-import os
+import bcrypt
+import uuid
+import smtplib
+import schedule
+import threading
+import time
 import json
-
-class DigitalHeir:
+import logging
+from email.mime.text import MIMEText
+from typing import Optional, Dict
+from dataclasses import dataclass
+import requests
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+
+@dataclass
+class AccountStatus:
+    last_active: datetime
+    is_active: bool
+    platform: str
+    username: str
+
+class ActivityMonitor:
     def __init__(self):
-        self.key = Fernet.generate_key()
-        self.cipher_suite = Fernet(self.key)
+        self.driver = webdriver.Chrome(headless=True)
+        self.platform_checkers = {
+            'facebook': self._check_facebook,
+            'twitter': self._check_twitter,
+            'instagram': self._check_instagram,
+            'linkedin': self._check_linkedin
+        }
     
-    def encrypt_data(self, data):
-        return self.cipher_suite.encrypt(str(data).encode())
+    def check_account_activity(self, platform: str, username: str) -> AccountStatus:
+        checker = self.platform_checkers.get(platform.lower())
+        if not checker:
+            raise ValueError(f"Unsupported platform: {platform}")
+        return checker(username)
     
-    def decrypt_data(self, encrypted_data):
-        return self.cipher_suite.decrypt(encrypted_data).decode()
-
-def create_connection():
-    conn = sqlite3.connect("digital_heir.db")
-    return conn
-
-def initialize_db():
-    conn = create_connection()
-    cursor = conn.cursor()
-
-    # Create tables if they don't exist
-    cursor.execute('''CREATE TABLE IF NOT EXISTS users (
-                        id TEXT PRIMARY KEY,
-                        username TEXT UNIQUE NOT NULL,
-                        password TEXT NOT NULL,
-                        role TEXT NOT NULL,
-                        created_at TEXT NOT NULL)''')
+    def _check_facebook(self, username: str) -> AccountStatus:
+        try:
+            url = f"https://www.facebook.com/{username}"
+            self.driver.get(url)
+            last_post = WebDriverWait(self.driver, 10).until(
+                EC.presence_of_element_located((By.CSS_SELECTOR, "[data-testid='post_timestamp']"))
+            )
+            last_active = datetime.fromisoformat(last_post.get_attribute('datetime'))
+            return AccountStatus(last_active, True, 'facebook', username)
+        except Exception as e:
+            logging.error(f"Error checking Facebook activity: {e}")
+            return AccountStatus(datetime.min, False, 'facebook', username)
+
+    # Similar implementations for other platforms...
+
+class DigitalInheritance:
+    def __init__(self, email_config: Dict):
+        self.key = self._load_or_create_key()
+        self.cipher_suite = Fernet(self.key)
+        self.db = Database()
+        self.activity_monitor = ActivityMonitor()
+        self.email_config = email_config
+        self._setup_scheduler()
+        self._setup_logging()
     
-    cursor.execute('''CREATE TABLE IF NOT EXISTS accounts (
-                        id TEXT PRIMARY KEY,
-                        user_id TEXT NOT NULL,
-                        platform TEXT NOT NULL,
-                        username TEXT NOT NULL,
-                        password TEXT NOT NULL,
-                        created_at TEXT NOT NULL,
-                        FOREIGN KEY (user_id) REFERENCES users(id))''')
+    def _load_or_create_key(self) -> bytes:
+        key_file = "encryption.key"
+        try:
+            with open(key_file, "rb") as f:
+                return f.read()
+        except FileNotFoundError:
+            key = Fernet.generate_key()
+            with open(key_file, "wb") as f:
+                f.write(key)
+            return key
     
-    cursor.execute('''CREATE TABLE IF NOT EXISTS heirs (
-                        id TEXT PRIMARY KEY,
-                        user_id TEXT NOT NULL,
-                        name TEXT NOT NULL,
-                        email TEXT NOT NULL,
-                        relationship TEXT NOT NULL,
-                        created_at TEXT NOT NULL,
-                        FOREIGN KEY (user_id) REFERENCES users(id))''')
-
-    conn.commit()
-    conn.close()
-
-def get_user_by_username(username):
-    conn = create_connection()
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM users WHERE username = ?", (username,))
-    user = cursor.fetchone()
-    conn.close()
-    return user
-
-def get_user_by_id(user_id):
-    conn = create_connection()
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))
-    user = cursor.fetchone()
-    conn.close()
-    return user
-
-def get_accounts_by_user_id(user_id):
-    conn = create_connection()
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM accounts WHERE user_id = ?", (user_id,))
-    accounts = cursor.fetchall()
-    conn.close()
-    return accounts
-
-def get_heirs_by_user_id(user_id):
-    conn = create_connection()
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM heirs WHERE user_id = ?", (user_id,))
-    heirs = cursor.fetchall()
-    conn.close()
-    return heirs
-
-def insert_user(username, password, role):
-    conn = create_connection()
-    cursor = conn.cursor()
-    user_id = str(uuid.uuid4())
-    cursor.execute("INSERT INTO users (id, username, password, role, created_at) VALUES (?, ?, ?, ?, ?)", 
-                   (user_id, username, password, role, datetime.now().isoformat()))
-    conn.commit()
-    conn.close()
-    return user_id
-
-def insert_account(user_id, platform, username, password):
-    conn = create_connection()
-    cursor = conn.cursor()
-    account_id = str(uuid.uuid4())
-    cursor.execute("INSERT INTO accounts (id, user_id, platform, username, password, created_at) VALUES (?, ?, ?, ?, ?, ?)", 
-                   (account_id, user_id, platform, username, password, datetime.now().isoformat()))
-    conn.commit()
-    conn.close()
-
-def insert_heir(user_id, name, email, relationship):
-    conn = create_connection()
-    cursor = conn.cursor()
-    heir_id = str(uuid.uuid4())
-    cursor.execute("INSERT INTO heirs (id, user_id, name, email, relationship, created_at) VALUES (?, ?, ?, ?, ?, ?)", 
-                   (heir_id, user_id, name, email, relationship, datetime.now().isoformat()))
-    conn.commit()
-    conn.close()
-
-def delete_account(account_id):
-    conn = create_connection()
-    cursor = conn.cursor()
-    cursor.execute("DELETE FROM accounts WHERE id = ?", (account_id,))
-    conn.commit()
-    conn.close()
-
-def delete_heir(heir_id):
-    conn = create_connection()
-    cursor = conn.cursor()
-    cursor.execute("DELETE FROM heirs WHERE id = ?", (heir_id,))
-    conn.commit()
-    conn.close()
-
-def delete_user(user_id):
-    conn = create_connection()
-    cursor = conn.cursor()
-    cursor.execute("DELETE FROM users WHERE id = ?", (user_id,))
-    cursor.execute("DELETE FROM accounts WHERE user_id = ?", (user_id,))
-    cursor.execute("DELETE FROM heirs WHERE user_id = ?", (user_id,))
-    conn.commit()
-    conn.close()
-
-def initialize_state():
-    if 'current_user' not in st.session_state:
-        st.session_state.current_user = None
-
-def show_auth():
-    tab1, tab2 = st.tabs(["Login", "Register"])
+    def _setup_scheduler(self):
+        schedule.every(12).hours.do(self.check_inactive_accounts)
+        thread = threading.Thread(target=self._run_scheduler, daemon=True)
+        thread.start()
     
-    with tab1:
-        with st.form("login_form"):
-            username = st.text_input("Username")
-            password = st.text_input("Password", type="password")
+    def check_inactive_accounts(self):
+        accounts = self.db.get_pending_accounts()
+        for account in accounts:
+            status = self.activity_monitor.check_account_activity(
+                account['platform'], 
+                account['username']
+            )
             
-            if st.form_submit_button("Login"):
-                login_user(username, password)
+            if not status.is_active:
+                days_inactive = (datetime.now() - status.last_active).days
+                if days_inactive >= account['inactivity_threshold']:
+                    self._trigger_inheritance(account)
     
-    with tab2:
-        with st.form("register_form"):
-            new_username = st.text_input("Username")
-            new_password = st.text_input("Password", type="password")
-            confirm_password = st.text_input("Confirm Password", type="password")
+    def _trigger_inheritance(self, account: Dict):
+        try:
+            heir = self.db.get_heir(account['heir_id'])
+            decrypted_password = self.cipher_suite.decrypt(
+                account['password'].encode()
+            ).decode()
             
-            if st.form_submit_button("Register"):
-                register_user(new_username, new_password, confirm_password)
-
-def login_user(username, password):
-    user = get_user_by_username(username)
-    if user and bcrypt.checkpw(password.encode(), user[2].encode()):
-        st.session_state.current_user = {'id': user[0], 'username': user[1], 'role': user[3]}
-        st.success("Login successful!")
-        st.rerun()
-    else:
-        st.error("Invalid username or password")
-
-def register_user(username, password, confirm_password):
-    if password != confirm_password:
-        st.error("Passwords do not match")
-        return
-    
-    if get_user_by_username(username):
-        st.error("Username already exists")
-        return
-    
-    password_hash = bcrypt.hashpw(password.encode(), bcrypt.gensalt())
-    user_id = insert_user(username, password_hash, 'user')
-    st.session_state.current_user = {'id': user_id, 'username': username, 'role': 'user'}
-    st.success("Registration successful! Please login.")
-
-def show_user_accounts():
-    st.title("My Accounts")
-    user_id = st.session_state.current_user['id']
+            self._send_credentials_email(
+                heir['email'],
+                account['platform'],
+                account['username'],
+                decrypted_password
+            )
+            
+            self.db.update_account_status(
+                account['id'], 
+                'inherited',
+                datetime.now().isoformat()
+            )
+            
+            logging.info(f"Inheritance triggered for account {account['id']}")
+        except Exception as e:
+            logging.error(f"Error in inheritance process: {e}")
+
+    def _send_credentials_email(self, email: str, platform: str, 
+                              username: str, password: str):
+        msg = MIMEText(self._generate_email_content(platform, username, password))
+        msg['Subject'] = 'Digital Account Access Information'
+        msg['From'] = self.email_config['sender']
+        msg['To'] = email
+        
+        with smtplib.SMTP_SSL(self.email_config['smtp_server'], 
+                             self.email_config['port']) as server:
+            server.login(self.email_config['username'], 
+                        self.email_config['password'])
+            server.send_message(msg)
+
+def create_account_ui():
+    st.title("Digital Account Setup")
     
-    with st.form("add_account"):
-        st.subheader("Add New Account")
-        platform = st.text_input("Platform Name")
-        username = st.text_input("Username/Email")
+    with st.form("account_setup"):
+        platform = st.selectbox(
+            "Platform",
+            ["Facebook", "Twitter", "Instagram", "LinkedIn"]
+        )
+        username = st.text_input("Username")
         password = st.text_input("Password", type="password")
+        heir = st.selectbox(
+            "Select Heir",
+            options=get_user_heirs(),
+            format_func=lambda x: x['name']
+        )
+        inactive_days = st.slider(
+            "Days of Inactivity Before Transfer",
+            min_value=30,
+            max_value=365,
+            value=90
+        )
         
-        if st.form_submit_button("Add Account"):
-            insert_account(user_id, platform, username, app.encrypt_data(password))
-            st.success("Account added successfully!")
-            st.rerun()
-    
-    st.subheader("My Accounts")
-    accounts = get_accounts_by_user_id(user_id)
-    for account in accounts:
-        with st.expander(f"{account[2]} - {account[3]}"):
-            st.write(f"Created: {account[5]}")
-            if st.button("Delete Account", key=f"del_acc_{account[0]}"):
-                delete_account(account[0])
-                st.success("Account deleted successfully!")
-                st.rerun()
+        if st.form_submit_button("Save Account"):
+            save_social_account(
+                platform=platform,
+                username=username,
+                password=password,
+                heir_id=heir['id'],
+                inactive_days=inactive_days
+            )
+            st.success("Account saved successfully!")
 
-def show_user_heirs():
-    st.title("My Heirs")
-    user_id = st.session_state.current_user['id']
+def main():
+    st.set_page_config(
+        page_title="Digital Inheritance System",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
     
-    with st.form("add_heir"):
-        st.subheader("Add New Heir")
-        name = st.text_input("Full Name")
-        email = st.text_input("Email Address")
-        relationship = st.text_input("Relationship")
-        
-        if st.form_submit_button("Add Heir"):
-            insert_heir(user_id, name, email, relationship)
-            st.success("Heir added successfully!")
-            st.rerun()
+    email_config = {
+        'smtp_server': st.secrets["SMTP_SERVER"],
+        'port': st.secrets["SMTP_PORT"],
+        'username': st.secrets["SMTP_USERNAME"],
+        'password': st.secrets["SMTP_PASSWORD"],
+        'sender': st.secrets["SENDER_EMAIL"]
+    }
     
-    st.subheader("My Heirs")
-    heirs = get_heirs_by_user_id(user_id)
-    for heir in heirs:
-        with st.expander(f"{heir[2]} - {heir[3]}"):
-            st.write(f"Email: {heir[4]}")
-            st.write(f"Added: {heir[5]}")
-            if st.button("Delete Heir", key=f"del_heir_{heir[0]}"):
-                delete_heir(heir[0])
-                st.success("Heir deleted successfully!")
-                st.rerun()
-
-def main():
-    st.set_page_config(page_title="Digital Heir", layout="wide")
-    initialize_db()
-    initialize_state()
+    app = DigitalInheritance(email_config)
     
-    if not st.session_state.current_user:
-        show_auth()
+    if 'current_user' not in st.session_state:
+        show_login()
     else:
-        if st.session_state.current_user['role'] == 'admin':
-            show_admin_panel()
-        else:
-            show_user_panel()
-
-def show_admin_panel():
-    st.sidebar.title("Admin Panel")
-    menu = ["Users", "Settings"]
-    choice = st.sidebar.selectbox("Menu", menu)
-    
-    if choice == "Users":
-        show_user_management()
-    elif choice == "Settings":
-        show_admin_settings()
-
-def show_user_management():
-    st.title("User Management")
-    # User list (admin can see all users)
-    users = get_all_users()
-    for user in users:
-        if user[3] != 'admin':  # Skip the admin user
-            with st.expander(f"User: {user[1]}"):
-                st.write(f"Created: {user[4]}")
-                if st.button("Delete User", key=f"del_user_{user[0]}"):
-                    delete_user(user[0])
-                    st.success("User deleted successfully!")
-                    st.rerun()
-
-def get_all_users():
-    conn = create_connection()
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM users")
-    users = cursor.fetchall()
-    conn.close()
-    return users
-
-def show_admin_settings():
-    st.title("Admin Settings")
-    st.write("Admin settings and controls.")
+        show_dashboard(app)
 
 if __name__ == "__main__":
-    main()
+    main()