Rename Update_tracking.py to Update_tracker.py

Update_tracker.py

@@ -0,0 +1,122 @@
+import streamlit as st
+import requests
+from bs4 import BeautifulSoup
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+import gspread
+from oauth2client.service_account import ServiceAccountCredentials
+from dotenv import load_dotenv
+import os
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Function to fetch live recitals from the GDPR website
+def fetch_gdpr_recitals():
+    url = "https://gdpr-info.eu/recitals/"
+    response = requests.get(url)
+
+    if response.status_code != 200:
+        st.error("Failed to fetch data from the GDPR website.")
+        return {}
+
+    soup = BeautifulSoup(response.content, 'html.parser')
+    recitals = {}
+    articles = soup.find_all('div', class_='artikel')
+
+    for i, article in enumerate(articles):
+        if i >= 3:  # Limit to 3 recitals for the demo
+            break
+        link = article.find('a')['href']
+        number = article.find('span', class_='nummer').text.strip('()')
+        title = article.find('span', class_='titel').text.strip()
+
+        rec_response = requests.get(link)
+        if rec_response.status_code == 200:
+            rec_soup = BeautifulSoup(rec_response.content, 'html.parser')
+            content = rec_soup.find('div', class_='entry-content').get_text(strip=True)
+            recitals[number] = {'title': title, 'content': content}
+        else:
+            st.error(f"Failed to fetch recital {number} from {link}")
+
+    return recitals
+
+# Function to send email notifications
+def send_email(recitals):
+    sender_email = os.getenv("EMAIL_ADDRESS")
+    receiver_email = os.getenv("RECEIVER_EMAIL")
+    password = os.getenv("EMAIL_PASSWORD")
+
+    subject = "GDPR Recitals Update"
+    body = "New GDPR recitals have been fetched:\n\n"
+
+    for number, details in recitals.items():
+        body += f"Recital {number}: {details['title']}\n{details['content']}\n\n"
+
+    msg = MIMEMultipart()
+    msg['From'] = sender_email
+    msg['To'] = receiver_email
+    msg['Subject'] = subject
+    msg.attach(MIMEText(body, 'plain'))
+
+    try:
+        with smtplib.SMTP('smtp.gmail.com', 587) as server:
+            server.starttls()  # Secure the connection
+            server.login(sender_email, password)  # Log in
+            server.send_message(msg)  # Send the email
+            st.success("Email notification sent!")
+    except smtplib.SMTPAuthenticationError:
+        st.error("Failed to login: Check your email and password.")
+    except smtplib.SMTPConnectError:
+        st.error("Failed to connect to the SMTP server. Check your network connection.")
+    except smtplib.SMTPException as e:
+        st.error(f"SMTP error occurred: {str(e)}")  # Improved error message
+    except Exception as e:
+        st.error(f"Failed to send email: {str(e)}")  # General error message
+
+# Function to store data in Google Sheets
+def store_in_google_sheets(recitals):
+    scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
+    creds_path = os.getenv("GOOGLE_CREDENTIALS_PATH")
+
+    st.write(f"Google Credentials Path: {creds_path}")  # Debug statement
+
+    if not creds_path or not os.path.exists(creds_path):
+        st.error("Google credentials path is invalid or not set.")
+        return
+
+    creds = ServiceAccountCredentials.from_json_keyfile_name(creds_path, scope)
+    client = gspread.authorize(creds)
+
+    sheet_id = os.getenv("GOOGLE_SHEET_ID")
+    if not sheet_id:
+        st.error("Google Sheet ID is not set.")
+        return
+
+    sheet = client.open_by_key(sheet_id).sheet1
+
+    for number, details in recitals.items():
+        sheet.append_row([number, details['title'], details['content']])
+    st.success("Data stored in Google Sheets!")
+
+# Function to display the UP page
+def display_Update_tracker_page():
+    st.title("Update Tracker - GDPR Recitals")
+
+    if st.button("Fetch Live Recitals"):
+        with st.spinner("Fetching updates..."):
+            recitals = fetch_gdpr_recitals()
+            if recitals:
+                for number, details in recitals.items():
+                    st.markdown(f"*Recital {number}: {details['title']}*")
+                    st.write(details['content'])
+
+                send_email(recitals)
+                store_in_google_sheets(recitals)
+            else:
+                st.write("No recitals found.")
+
+# Run the display function
+if __name__ == "__main__":
+    display_Update_tracker_page()

Update_tracking.py

@@ -1,169 +0,0 @@
-import requests
-from bs4 import BeautifulSoup
-import time
-import streamlit as st
-import threading
-from datetime import datetime, timedelta
-import smtplib
-from email.message import EmailMessage
-import os
-from dotenv import load_dotenv
-from google.oauth2.service_account import Credentials
-from googleapiclient.discovery import build
-
-# Load environment variables from .env file
-load_dotenv()
-
-# Google Sheets Configuration
-SHEET_ID = '1bZjlA-UJrBhWS2jHlEQ-7nbmDvxpEoKylgxHW51Hhzc'  # Google Sheets ID
-RANGE = 'Sheet1!A:D'  # The range where you want to append the data
-
-# Predefined list of URLs to track
-TRACKING_URLS = [
-    "https://gdpr-info.eu/recitals/no-1/"]
-
-# Event to signal thread termination
-stop_event = threading.Event()
-
-# Authenticate Google Sheets API
-def authenticate_google_sheets():
-    creds = Credentials.from_service_account_file(
-        'Credentials.json',
-        scopes=['https://www.googleapis.com/auth/spreadsheets']
-    )
-    service = build('sheets', 'v4', credentials=creds)
-    return service
-
-# Append data to Google Sheets
-def append_to_google_sheets(service, url, title, content, timestamp):
-    values = [
-        [url, title, content[:200], timestamp]  # Prepare row to append
-    ]
-    body = {'values': values}
-    try:
-        service.spreadsheets().values().append(
-            spreadsheetId=SHEET_ID,
-            range=RANGE,
-            valueInputOption="RAW",
-            body=body
-        ).execute()
-        st.write(f"Data appended to Google Sheets at {timestamp}.")
-    except Exception as e:
-        st.error(f"Error appending to Google Sheets: {e}")
-
-# Send email notification
-def send_email_notification(to_email, url, title, content, timestamp):
-    sender_email = os.getenv("EMAIL_ADDRESS")
-    sender_password = os.getenv("EMAIL_PASSWORD")
-    smtp_server = "smtp.gmail.com"
-    smtp_port = 587
-
-    if not sender_email or not sender_password:
-        st.error("Environment variables not loaded. Check your .env file.")
-        return
-
-    msg = EmailMessage()
-    msg["Subject"] = f"Website Update Notification for {url}"
-    msg["From"] = sender_email
-    msg["To"] = to_email
-    msg.set_content(f"""
-    Website: {url}
-    Title: {title}
-    Content (preview): {content[:200]}...
-    Tracked at: {timestamp}
-    """)
-
-    try:
-        with smtplib.SMTP(smtp_server, smtp_port) as server:
-            server.starttls()
-            server.login(sender_email, sender_password)
-            server.send_message(msg)
-            st.success(f"Notification email sent to {to_email}")
-    except smtplib.SMTPException as e:
-        st.error(f"SMTP Error: {e}")
-
-# Fetch website data
-def fetch_website_data(url):
-    try:
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        soup = BeautifulSoup(response.text, 'html.parser')
-        title = soup.title.string.strip() if soup.title else 'No title available'
-        paragraphs = soup.find_all('p')
-        content = ' '.join([p.text.strip() for p in paragraphs]) if paragraphs else 'New Notification available'
-        return title, content
-    except requests.exceptions.RequestException as e:
-        st.error(f"Error fetching website data: {e}")
-        return "Error occurred", "New notification detected. No content available due to an error."
-
-# Track websites and store updates in Google Sheets
-def track_websites(urls, recipient_email, interval=60, max_duration=20*60):
-    st.write(f"Started tracking for {recipient_email}")
-    service = authenticate_google_sheets()
-    last_updates = {}  # To track changes in website content
-
-    start_time = datetime.now()  # Record the start time
-    end_time = start_time + timedelta(seconds=max_duration)  # Set end time (20 minutes later)
-
-    while not stop_event.is_set() and datetime.now() < end_time:
-        for url in urls:
-            title, content = fetch_website_data(url)
-            if title and content:
-                timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-
-                # Check for updates
-                if url not in last_updates or last_updates[url] != (title, content):
-                    last_updates[url] = (title, content)
-
-                    # Append to Google Sheets
-                    append_to_google_sheets(service, url, title, content, timestamp)
-
-                    # Send notification email
-                    try:
-                        send_email_notification(recipient_email, url, title, content, timestamp)
-                    except Exception as e:
-                        st.error(f"Error sending email notification: {e}")
-
-        # Wait for the next interval or until stop_event is set
-        stop_event.wait(interval)
-
-    st.write("Stopped tracking after 20 minutes.")
-
-# Display tracking status
-def display_tracking_status():
-    st.title("Update Tracking System with Notifications")
-
-    email_input = st.text_input("Enter your email for notifications:")
-
-    # Maintain thread state
-    if "tracking_thread" not in st.session_state:
-        st.session_state["tracking_thread"] = None
-
-    if email_input:
-        # Start tracking
-        if st.button("Tracking"):
-            if st.session_state["tracking_thread"] is None or not st.session_state["tracking_thread"].is_alive():
-                stop_event.clear()  # Clear the stop flag to allow tracking
-                thread = threading.Thread(target=track_websites, args=(TRACKING_URLS, email_input), daemon=True)
-                thread.start()
-                st.session_state["tracking_thread"] = thread
-                st.success(f"Notifications will be sent to {email_input}.")
-            else:
-                st.warning("Tracking Updates is already running.")
-
-        # Stop tracking
-        if st.button("Stop Tracking"):
-            if st.session_state["tracking_thread"] is not None and st.session_state["tracking_thread"].is_alive():
-                stop_event.set()  # Signal the thread to stop
-                st.session_state["tracking_thread"].join()  # Wait for the thread to finish
-                st.session_state["tracking_thread"] = None
-                st.success("Tracking stopped.")
-            else:
-                st.warning("No active tracking to stop.")
-
-# Main function
-def main():
-    display_tracking_status()
-
-if __name__ == "__main__":
-    main()