Update app.py

app.py

@@ -46,7 +46,8 @@ scheduler = CommitScheduler(
 
 # --- Globala variabler ---
 last_log = None  # Sparar loggdata från senaste svar för feedback
-
+# Lägg till i början av skriptet med andra globala variabler
+active_sessions = {}  # Dictionary för att spåra aktiva sessioner: {session_id: (senaste_tid, meddelanden)}
 # --- Slack Webhook funktionalitet ---
 def send_report_to_slack(subject, content):
     """Skickar rapport till Slack via webhook."""
@@ -288,31 +289,90 @@ def get_feedback_stats(logs):
 
 # Skicka statusrapport till Slack
 def send_status_slack():
-    """Skickar ett statusmeddelande till Slack med statistik."""
+    """Skickar ett statusmeddelande till Slack med utökad statistik."""
     print("Försöker skicka status-rapport till Slack...")
     
     try:
         # Samla in statistik
         logs = read_logs()
         
+        # Beräkna tid för 24 timmar sedan och 14 dagar sedan
+        now = datetime.now()
+        yesterday = now - timedelta(days=1)
+        two_weeks_ago = now - timedelta(days=14)
+        
+        # Konvertera timestamps till datetime
+        for log in logs:
+            if 'timestamp' in log:
+                try:
+                    log['datetime'] = datetime.strptime(log['timestamp'], "%Y-%m-%d %H:%M:%S")
+                except:
+                    log['datetime'] = now  # Default om formatering misslyckas
+        
+        # Filtrera loggar för senaste 24h och 14 dagar
+        logs_24h = [log for log in logs if 'datetime' in log and log['datetime'] >= yesterday]
+        logs_14d = [log for log in logs if 'datetime' in log and log['datetime'] >= two_weeks_ago]
+        
         # 1. Samla statistik
         conversations = get_latest_conversations(logs)
         feedback_stats, negative_examples = get_feedback_stats(logs)
+        
+        # Basinformation
         total_sessions = len(set(log.get('session_id', 'unknown') for log in logs if 'session_id' in log))
         total_questions = sum(1 for log in logs if 'user_message' in log)
         
+        # 24h statistik
+        sessions_24h = len(set(log.get('session_id', 'unknown') for log in logs_24h if 'session_id' in log))
+        messages_24h = sum(1 for log in logs_24h if 'user_message' in log)
+        
+        # Beräkna snitt antal meddelanden per session (om minst en session finns)
+        avg_messages_per_session = round(messages_24h / sessions_24h, 2) if sessions_24h > 0 else 0
+        
+        # Snittsvarstid
+        response_times_24h = [log.get('response_time', 0) for log in logs_24h if 'response_time' in log]
+        avg_response_time = round(sum(response_times_24h) / len(response_times_24h), 2) if response_times_24h else 0
+        
+        # 14 dagars statistik
+        messages_14d = sum(1 for log in logs_14d if 'user_message' in log)
+        unique_users_14d = len(set(log.get('user_id', 'unknown') for log in logs_14d if 'user_id' in log))
+        
+        # Likes och dislikes
+        likes_24h = sum(1 for log in logs_24h if log.get('feedback') == 'up')
+        dislikes_24h = sum(1 for log in logs_24h if log.get('feedback') == 'down')
+        
+        # Browser-fördelning
+        browser_counts = {}
+        for log in logs_24h:
+            if 'browser' in log:
+                browser = log['browser']
+                browser_counts[browser] = browser_counts.get(browser, 0) + 1
+        
+        # Sortera browsers efter antal
+        top_browsers = sorted(browser_counts.items(), key=lambda x: x[1], reverse=True)[:3]
+        browser_text = ", ".join([f"{browser}: {count}" for browser, count in top_browsers]) if top_browsers else "Ingen data"
+        
         # 2. Formatera för Slack (Markdown)
-        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        subject = f"ChargeNode AI Bot - Status {now}"
+        slack_date = now.strftime("%Y-%m-%d")
+        subject = f"ChargeNode AI Bot - Daglig rapport {slack_date}"
         
         content = f"""
-*ChargeNode AI Bot - Statusrapport {now}*
+*ChargeNode AI Bot - Statusrapport {now.strftime('%Y-%m-%d %H:%M:%S')}*
 
 *Sammanfattning*
+- Datum: {slack_date}
+- Antal meddelanden senaste 24h: {messages_24h}
+- Unika sessioner senaste 24h: {sessions_24h}
+- Meddelanden per session (snitt): {avg_messages_per_session}
+- Snittsvarstid senaste 24h: {avg_response_time} sekunder
+- Antal meddelanden (14 dagar): {messages_14d}
+- Unika användare (14 dagar): {unique_users_14d}
+- Tumme upp senaste 24h: {likes_24h}
+- Tumme ned senaste 24h: {dislikes_24h}
+- Browser-fördelning senaste 24h: {browser_text}
+
+*Trender*
 - Totalt antal sessioner: {total_sessions}
 - Totalt antal frågor: {total_questions}
-- Tumme upp: {feedback_stats['up']}
-- Tumme ned: {feedback_stats['down']}
 
 *De 5 senaste frågorna*
 """
@@ -350,6 +410,137 @@ def send_status_slack():
         print(f"Fel vid sändning av status-rapport till Slack: {e}")
         return False
 
+# Funktion för att skicka en avslutad session till Slack
+def send_session_to_slack(session_id, messages):
+    """Skickar en avslutad chatsession till Slack."""
+    if not messages:
+        return False
+    
+    try:
+        user_messages = [msg for msg in messages if msg.get('role') == 'user']
+        bot_messages = [msg for msg in messages if msg.get('role') == 'assistant']
+        
+        if not user_messages:
+            return False  # Ingen användarsession att rapportera
+        
+        # Räkna feedback
+        likes = sum(1 for msg in messages if msg.get('feedback') == 'up')
+        dislikes = sum(1 for msg in messages if msg.get('feedback') == 'down')
+        
+        # Hämta information om sessionen
+        first_msg_time = messages[0].get('timestamp', 'okänd tid')
+        last_msg_time = messages[-1].get('timestamp', 'okänd tid')
+        
+        # Formatera sessionen för Slack
+        subject = f"Avslutad chatsession {session_id[:8]} - {first_msg_time}"
+        
+        content = f"""
+*Chatsession avslutad*
+- *Session ID:* {session_id[:8]}...
+- *Starttid:* {first_msg_time}
+- *Sluttid:* {last_msg_time}
+- *Antal frågor:* {len(user_messages)}
+- *Antal svar:* {len(bot_messages)}
+- *Tumme upp:* {likes}
+- *Tumme ned:* {dislikes}
+
+*Konversation:*
+"""
+        
+        # Lägg till konversationen
+        for i, msg in enumerate(messages):
+            if msg.get('role') == 'user':
+                content += f"> *Användare:* {msg.get('content', '')}\n\n"
+            elif msg.get('role') == 'assistant':
+                content += f"> *Bot:* {msg.get('content', '')[:150]}...\n\n"
+        
+        # Skicka till Slack
+        success = send_report_to_slack(subject, content)
+        return success
+    except Exception as e:
+        print(f"Fel vid sändning av sessionrapport till Slack: {e}")
+        return False
+
+# Modifiera respond-funktionen för att spåra sessioner
+def respond(message, chat_history, request: gr.Request):
+    global last_log, active_sessions
+    start = time.time()
+    response = generate_answer(message)
+    elapsed = round(time.time() - start, 2)
+
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    session_id = str(uuid.uuid4())
+    user_id = request.client.host if request else "okänd"
+
+    # Resten av din befintliga kod här...
+    
+    # Spara sessionsdata för chattrapporter
+    if last_log and 'session_id' in last_log:
+        # Använd session_id från tidigare logg om det finns
+        session_id = last_log.get('session_id')
+    
+    # Uppdatera aktiva sessioner
+    if session_id not in active_sessions:
+        active_sessions[session_id] = {
+            'last_activity': datetime.now(),
+            'messages': []
+        }
+    
+    # Lägg till användarfråga
+    active_sessions[session_id]['messages'].append({
+        'role': 'user',
+        'content': message,
+        'timestamp': timestamp
+    })
+    
+    # Lägg till bot-svar
+    active_sessions[session_id]['messages'].append({
+        'role': 'assistant',
+        'content': response,
+        'timestamp': timestamp
+    })
+    
+    # Uppdatera senaste aktivitet
+    active_sessions[session_id]['last_activity'] = datetime.now()
+    
+    # Fortsätt med din befintliga kod...
+    chat_history.append({"role": "user", "content": message})
+    chat_history.append({"role": "assistant", "content": response})
+    return "", chat_history
+
+# Periodisk kontroll av inaktiva sessioner
+def check_inactive_sessions():
+    """Kontrollerar efter inaktiva sessioner och skickar dem till Slack."""
+    now = datetime.now()
+    sessions_to_remove = []
+    
+    for session_id, session_data in active_sessions.items():
+        last_activity = session_data['last_activity']
+        inactive_time = (now - last_activity).total_seconds() / 60  # i minuter
+        
+        if inactive_time >= 2:  # Inaktiv i minst 2 minuter
+            # Skicka sessionen till Slack
+            send_session_to_slack(session_id, session_data['messages'])
+            sessions_to_remove.append(session_id)
+    
+    # Ta bort skickade sessioner
+    for session_id in sessions_to_remove:
+        del active_sessions[session_id]
+
+# Uppdatera schemaläggningsfunktionen för att kontrollera inaktiva sessioner
+def run_scheduler():
+    """Kör schemaläggaren i en separat tråd."""
+    # Schemalägga rapporter till Slack
+    schedule.every().day.at("09:32").do(send_status_slack)
+    schedule.every().day.at("15:00").do(send_status_slack)
+    schedule.every().day.at("08:00").do(send_status_slack)
+    
+    # Kontrollera inaktiva sessioner var 30:e sekund
+    schedule.every(30).seconds.do(check_inactive_sessions)
+    
+    while True:
+        schedule.run_pending()
+        time.sleep(10)  # Kontrollera var 10:e sekund
 def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
     """Skickar en supportförfrågan till Slack."""
     try: