Create app.py

app.py

@@ -0,0 +1,825 @@
+import os
+import json
+import time
+import uuid
+import datetime
+import torch
+import gradio as gr
+import numpy as np
+import nltk
+from nltk.sentiment import SentimentIntensityAnalyzer
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+try:
+    from transformers import pipeline
+except ImportError as e:
+    print(f"Failed to import transformers: {e}")
+    print("Attempting to use a fallback model or configuration...")
+    pipeline = None
+
+# Download NLTK resources
+nltk.download('vader_lexicon', quiet=True)
+nltk.download('punkt', quiet=True)
+nltk.download('stopwords', quiet=True)
+
+# Check if GPU is available
+print(f"GPU available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"GPU name: {torch.cuda.get_device_name(0)}")
+
+# Initialize sentiment analyzer
+sia = SentimentIntensityAnalyzer()
+
+# Data storage
+class DataStore:
+    def __init__(self):
+        self.users = {}
+        self.blogs = {}
+        self.comments = {}
+        self.chats = {}
+        self.user_interactions = {}
+        self.current_user_id = None
+        self.create_sample_data()
+
+    def create_sample_data(self):
+        user_ids = [self.add_user("admin", "admin123", "admin@example.com", "Admin User", "admin")]
+        user_ids.extend([self.add_user(f"blogger{i}", f"password{i}", f"blogger{i}@example.com", f"Blogger {i}", "blogger") for i in range(1, 4)])
+        user_ids.extend([self.add_user(f"reader{i}", f"password{i}", f"reader{i}@example.com", f"Reader {i}", "reader") for i in range(1, 6)])
+
+        blog_topics = [
+            "Machine Learning Fundamentals",
+            "Web Development Best Practices",
+            "Data Science in Practice",
+            "Python Programming Tips",
+            "Neural Networks Explained",
+            "Modern JavaScript Frameworks",
+            "Cloud Computing Services"
+        ]
+
+        blog_contents = [
+            "Machine learning is a branch of artificial intelligence that enables computers to learn from data without being explicitly programmed...",
+            "Web development involves creating websites and web applications using technologies like HTML, CSS, and JavaScript...",
+            "Data science combines domain expertise, programming skills, and knowledge of math and statistics to extract meaningful insights from data...",
+            "Python is a versatile programming language widely used in various domains including web development, data analysis, and artificial intelligence...",
+            "Neural networks are computing systems inspired by the biological neural networks that constitute animal brains...",
+            "Modern JavaScript frameworks like React, Vue, and Angular have revolutionized front-end web development...",
+            "Cloud computing services provide businesses with on-demand access to computing resources without direct active management by the user..."
+        ]
+
+        blog_ids = []
+        for i in range(len(blog_topics)):
+            author_id = user_ids[1 + (i % 3)]
+            blog_id = self.add_blog(blog_topics[i], blog_contents[i], author_id, ["tech", "programming"])
+            blog_ids.append(blog_id)
+            for j in range(3):
+                commenter_id = user_ids[4 + (j % 5)]
+                self.add_comment(blog_id, f"Great article on {blog_topics[i]}!", commenter_id)
+            for user_id in user_ids[4:]:
+                self.record_interaction(user_id, blog_id, np.random.randint(1, 10))
+
+    def add_user(self, username, password, email, display_name, role):
+        user_id = str(uuid.uuid4())
+        self.users[user_id] = {
+            "id": user_id,
+            "username": username,
+            "password": password,
+            "email": email,
+            "display_name": display_name,
+            "role": role,
+            "created_at": datetime.datetime.now().isoformat(),
+            "badges": []
+        }
+        return user_id
+
+    def add_blog(self, title, content, author_id, tags):
+        blog_id = str(uuid.uuid4())
+        self.blogs[blog_id] = {
+            "id": blog_id,
+            "title": title,
+            "content": content,
+            "author_id": author_id,
+            "tags": tags,
+            "created_at": datetime.datetime.now().isoformat(),
+            "updated_at": datetime.datetime.now().isoformat(),
+            "comments": [],
+            "likes": 0,
+            "views": 0
+        }
+        return blog_id
+
+    def add_comment(self, blog_id, content, user_id):
+        comment_id = str(uuid.uuid4())
+        self.comments[comment_id] = {
+            "id": comment_id,
+            "blog_id": blog_id,
+            "content": content,
+            "user_id": user_id,
+            "created_at": datetime.datetime.now().isoformat()
+        }
+        self.blogs[blog_id]["comments"].append(comment_id)
+        return comment_id
+
+    def add_chat_message(self, chat_id, content, user_id):
+        if chat_id not in self.chats:
+            self.chats[chat_id] = {
+                "id": chat_id,
+                "messages": [],
+                "participants": []
+            }
+        message_id = str(uuid.uuid4())
+        message = {
+            "id": message_id,
+            "content": content,
+            "user_id": user_id,
+            "created_at": datetime.datetime.now().isoformat()
+        }
+        self.chats[chat_id]["messages"].append(message)
+        if user_id not in self.chats[chat_id]["participants"]:
+            self.chats[chat_id]["participants"].append(user_id)
+        return message_id
+
+    def record_interaction(self, user_id, blog_id, interaction_value):
+        if user_id not in self.user_interactions:
+            self.user_interactions[user_id] = {}
+        if blog_id not in self.user_interactions[user_id]:
+            self.user_interactions[user_id][blog_id] = 0
+        self.user_interactions[user_id][blog_id] += interaction_value
+
+    def authenticate_user(self, username, password):
+        for user_id, user in self.users.items():
+            if user["username"] == username and user["password"] == password:
+                return user_id
+        return None
+
+    def get_user_blogs(self, user_id):
+        return {blog_id: blog for blog_id, blog in self.blogs.items() if blog["author_id"] == user_id}
+
+    def get_all_blogs(self):
+        return self.blogs
+
+    def get_blog_by_id(self, blog_id):
+        return self.blogs.get(blog_id)
+
+    def get_user_by_id(self, user_id):
+        return self.users.get(user_id)
+
+    def get_chat_by_id(self, chat_id):
+        return self.chats.get(chat_id)
+
+    def get_comments_for_blog(self, blog_id):
+        blog = self.blogs.get(blog_id)
+        if not blog:
+            return []
+        comments = []
+        for comment_id in blog["comments"]:
+            comment = self.comments.get(comment_id)
+            if comment:
+                comments.append(comment)
+        return comments
+
+# Initialize data store
+data_store = DataStore()
+
+# Machine Learning Models
+class MLModels:
+    def __init__(self):
+        self.sentiment_model_name = "distilbert-base-uncased-finetuned-sst-2-english"
+        self.sentiment_analyzer = None
+        if pipeline is not None:
+            try:
+                self.sentiment_analyzer = pipeline("sentiment-analysis", model=self.sentiment_model_name, device=0 if torch.cuda.is_available() else -1)
+            except Exception as e:
+                print(f"Failed to initialize sentiment analyzer: {e}")
+                print("Falling back to NLTK sentiment analysis")
+        self.tfidf_vectorizer = TfidfVectorizer(max_features=1000)
+        self.blog_vectors = None
+        self.update_blog_vectors()
+
+    def update_blog_vectors(self):
+        blog_contents = [f"{blog['title']} {' '.join(blog['tags'])} {blog['content']}"
+                         for blog in data_store.blogs.values()]
+        if blog_contents:
+            self.blog_vectors = self.tfidf_vectorizer.fit_transform(blog_contents)
+        else:
+            self.blog_vectors = None
+
+    def analyze_sentiment(self, text):
+        if self.sentiment_analyzer is not None:
+            try:
+                result = self.sentiment_analyzer(text, truncation=True, max_length=512)[0]
+                score = result["score"] if result["label"] == "POSITIVE" else 1 - result["score"]
+                return {
+                    "score": float(score),
+                    "label": result["label"].lower(),
+                    "is_inappropriate": score < 0.2
+                }
+            except Exception as e:
+                print(f"Sentiment analysis failed: {e}")
+        vader_scores = sia.polarity_scores(text)
+        score = (vader_scores['compound'] + 1) / 2
+        return {
+            "score": float(score),
+            "label": "positive" if score > 0.5 else "negative",
+            "is_inappropriate": score < 0.2
+        }
+
+    def recommend_blogs(self, user_id, limit=5):
+        if user_id not in data_store.user_interactions or len(data_store.user_interactions[user_id]) < 2:
+            return self.content_based_recommendations(user_id, limit)
+        else:
+            return self.collaborative_filtering(user_id, limit)
+
+    def content_based_recommendations(self, user_id, limit=5):
+        user_blogs = data_store.user_interactions.get(user_id, {})
+        if not user_blogs:
+            blog_ids = list(data_store.blogs.keys())
+            np.random.shuffle(blog_ids)
+            return blog_ids[:limit]
+        user_profile = np.zeros(self.blog_vectors.shape[1])
+        total_interactions = 0
+        for blog_id, interaction_count in user_blogs.items():
+            blog_idx = list(data_store.blogs.keys()).index(blog_id)
+            user_profile += interaction_count
+            total_interactions += interaction_count
+        if total_interactions > 0:
+            user_profile /= total_interactions
+        similarities = []
+        for i, blog_id in enumerate(data_store.blogs.keys()):
+            if blog_id not in user_blogs:
+                blog_vector = self.blog_vectors[i].toarray()[0]
+                similarity = np.dot(user_profile, blog_vector) / (np.linalg.norm(user_profile) * np.linalg.norm(blog_vector) + 1e-8)
+                similarities.append((blog_id, similarity))
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return [blog_id for blog_id, _ in similarities[:limit]]
+
+    def collaborative_filtering(self, user_id, limit=5):
+        user_ids = list(data_store.user_interactions.keys())
+        blog_ids = list(data_store.blogs.keys())
+        if user_id not in user_ids:
+            return self.content_based_recommendations(user_id, limit)
+        interaction_matrix = np.zeros((len(user_ids), len(blog_ids)))
+        for i, u_id in enumerate(user_ids):
+            for j, b_id in enumerate(blog_ids):
+                interaction_matrix[i, j] = data_store.user_interactions.get(u_id, {}).get(b_id, 0)
+        user_similarity = cosine_similarity(interaction_matrix)
+        user_idx = user_ids.index(user_id)
+        similar_users = [(user_ids[i], user_similarity[user_idx, i])
+                        for i in range(len(user_ids)) if i != user_idx]
+        similar_users.sort(key=lambda x: x[1], reverse=True)
+        recommendations = {}
+        for similar_user_id, similarity in similar_users[:5]:
+            similar_user_idx = user_ids.index(similar_user_id)
+            for j, blog_id in enumerate(blog_ids):
+                if blog_id in data_store.user_interactions.get(user_id, {}):
+                    continue
+                if interaction_matrix[similar_user_idx, j] > 0:
+                    if blog_id not in recommendations:
+                        recommendations[blog_id] = 0
+                    recommendations[blog_id] += similarity * interaction_matrix[similar_user_idx, j]
+        sorted_recommendations = sorted(recommendations.items(), key=lambda x: x[1], reverse=True)
+        return [blog_id for blog_id, _ in sorted_recommendations[:limit]]
+
+    def moderate_text(self, text):
+        sentiment_result = self.analyze_sentiment(text)
+        is_inappropriate = sentiment_result["is_inappropriate"]
+        banned_words = ["hate", "spam", "offensive", "racist", "sexist"]
+        contains_banned_words = any(word in text.lower() for word in banned_words)
+        return {
+            "is_flagged": is_inappropriate or contains_banned_words,
+            "sentiment": sentiment_result["label"],
+            "confidence": sentiment_result["score"]
+        }
+
+# Initialize ML models
+ml_models = MLModels()
+
+# Custom CSS
+custom_css = """
+body {
+    font-family: 'Arial', sans-serif;
+    background-color: #f4f7fb;
+}
+.header {
+    background-color: #2c3e50;
+    color: white;
+    padding: 15px;
+    text-align: center;
+    border-radius: 8px;
+    margin-bottom: 20px;
+}
+.card {
+    background-color: white;
+    border-radius: 8px;
+    box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+    padding: 15px;
+    margin-bottom: 15px;
+    transition: transform 0.2s;
+}
+.card:hover {
+    transform: translateY(-2px);
+}
+.gr-button {
+    background-color: #3498db;
+    color: white;
+    border: none;
+    border-radius: 5px;
+    padding: 10px 20px;
+    font-size: 16px;
+    cursor: pointer;
+    transition: background-color 0.2s;
+}
+.gr-button:hover {
+    background-color: #2980b9;
+}
+.gr-button.secondary {
+    background-color: #7f8c8d;
+}
+.gr-button.secondary:hover {
+    background-color: #636e72;
+}
+.gr-textbox {
+    border-radius: 5px;
+    border: 1px solid #dcdcdc;
+    padding: 10px;
+}
+.tab-nav button {
+    border-radius: 5px 5px 0 0 !important;
+}
+.tab-nav button[aria-selected="true"] {
+    background-color: #3498db !important;
+    color: white !important;
+}
+@media (max-width: 768px) {
+    .card {
+        padding: 10px;
+    }
+    .gr-button {
+        padding: 8px 15px;
+        font-size: 14px;
+    }
+}
+"""
+
+# Gradio Interface
+def create_interface():
+    with gr.Blocks(css=custom_css) as interface:
+        user_id_state = gr.State("")
+
+        # Header
+        gr.Markdown("<div class='header'><h1>BlogSphere</h1><p>Your hub for tech insights and discussions</p></div>")
+
+        # Authentication
+        with gr.Group() as auth_group:
+            with gr.Row():
+                with gr.Column(scale=1, min_width=300):
+                    gr.Markdown("## Sign In")
+                    username_input = gr.Textbox(label="Username", placeholder="Enter your username")
+                    password_input = gr.Textbox(label="Password", type="password", placeholder="Enter your password")
+                    login_button = gr.Button("Login")
+                    login_status = gr.Textbox(label="Status", interactive=False, placeholder="Login status will appear here")
+
+        # Main interface
+        with gr.Group(visible=False) as main_group:
+            current_blog_id = gr.State("")
+            current_chat_id = gr.State("")
+
+            # Navigation bar
+            with gr.Row():
+                refresh_button = gr.Button("Refresh Content", variant="secondary")
+
+            # Tabs
+            with gr.Tabs() as tabs:
+                # Blog Feed Tab
+                with gr.TabItem("Blog Feed"):
+                    gr.Markdown("## Explore Blogs")
+                    with gr.Row():
+                        with gr.Column(scale=3):
+                            blog_list = gr.HTML()
+                            blog_refresh_button = gr.Button("Load More Blogs", variant="secondary")
+
+                        with gr.Column(scale=1):
+                            gr.Markdown("## Recommended For You")
+                            recommended_blogs = gr.HTML()
+
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("## Blog Content")
+                            blog_title = gr.Textbox(label="Title", interactive=False)
+                            blog_author = gr.Textbox(label="Author", interactive=False)
+                            blog_content = gr.Textbox(label="Content", lines=10, interactive=False)
+                            blog_tags = gr.Textbox(label="Tags", interactive=False)
+
+                            with gr.Accordion("Comments", open=False):
+                                blog_comments = gr.HTML()
+                                new_comment = gr.Textbox(label="Add a comment", placeholder="Write your comment here")
+                                submit_comment = gr.Button("Submit Comment")
+
+                # My Blogs Tab
+                with gr.TabItem("My Blogs"):
+                    gr.Markdown("## My Published Blogs")
+                    my_blogs_list = gr.HTML()
+
+                    with gr.Accordion("Create New Blog", open=False):
+                        new_blog_title = gr.Textbox(label="Title", placeholder="Enter blog title")
+                        new_blog_content = gr.Textbox(label="Content", lines=10, placeholder="Write your blog content here")
+                        new_blog_tags = gr.Textbox(label="Tags", placeholder="Enter tags, separated by commas")
+                        create_blog_button = gr.Button("Publish Blog")
+                        blog_create_status = gr.Textbox(label="Status", interactive=False)
+
+                # Chat Tab
+                with gr.TabItem("Chat"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            gr.Markdown("## Chat Rooms")
+                            chat_list = gr.HTML()
+                            new_chat_name = gr.Textbox(label="New Chat Room Name", placeholder="Enter chat room name")
+                            create_chat_button = gr.Button("Create Chat Room")
+
+                        with gr.Column(scale=2):
+                            gr.Markdown("## Chat")
+                            chat_messages = gr.Chatbot(label="Messages")
+                            new_message = gr.Textbox(label="Message", placeholder="Type your message")
+                            send_message_button = gr.Button("Send")
+                            moderation_status = gr.Textbox(label="Moderation Status", interactive=False)
+
+                # Profile Tab
+                with gr.TabItem("Profile"):
+                    gr.Markdown("## User Profile")
+                    display_name = gr.Textbox(label="Display Name", placeholder="Enter display name")
+                    email = gr.Textbox(label="Email", placeholder="Enter email")
+                    user_role = gr.Textbox(label="Role", interactive=False)
+                    user_badges = gr.Textbox(label="Badges", interactive=False)
+                    update_profile_button = gr.Button("Update Profile")
+                    profile_update_status = gr.Textbox(label="Status", interactive=False)
+                    logout_button = gr.Button("Logout", variant="secondary")
+
+        # Helper functions
+        def format_blog_card(blog_id, blog, author_name, is_recommended=False):
+            title = blog["title"]
+            tags = ", ".join(blog["tags"])
+            likes = blog["likes"]
+            views = blog["views"]
+            snippet = blog["content"][:100] + "..." if len(blog["content"]) > 100 else blog["content"]
+            return f"""
+            <div class='card' onclick='selectBlog("{blog_id}")'>
+                <h3>{title}</h3>
+                <p><b>Author:</b> {author_name}</p>
+                <p>{snippet}</p>
+                <p><b>Tags:</b> {tags}</p>
+                <p><b>Likes:</b> {likes} | <b>Views:</b> {views}</p>
+            </div>
+            """
+
+        def format_comment_card(comment, user_name):
+            content = comment["content"]
+            date = comment["created_at"]
+            return f"""
+            <div class='card'>
+                <p><b>{user_name}</b> - {date}</p>
+                <p>{content}</p>
+            </div>
+            """
+
+        def format_chat_room_card(chat_id, participants):
+            return f"""
+            <div class='card' onclick='selectChat("{chat_id}")'>
+                <h4>Chat Room {chat_id[:8]}</h4>
+                <p><b>Participants:</b> {', '.join(participants)}</p>
+            </div>
+            """
+
+        # Functions
+        def login(username, password):
+            user_id = data_store.authenticate_user(username, password)
+            if user_id:
+                user = data_store.get_user_by_id(user_id)
+                data_store.current_user_id = user_id
+                recommended = load_recommended_blogs(user_id)
+                user_blogs = load_user_blogs(user_id)
+                profile_data = load_user_profile(user_id)
+                chat_rooms = load_chat_rooms()
+                return (
+                    user_id,
+                    f"Welcome back, {user['display_name']}!",
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                    recommended,
+                    user_blogs,
+                    chat_rooms,
+                    profile_data[0],
+                    profile_data[1],
+                    profile_data[2],
+                    profile_data[3]
+                )
+            else:
+                return "", "Invalid username or password", gr.update(visible=True), gr.update(visible=False), "", "", "", "", "", "", ""
+
+        def load_blogs():
+            blogs = data_store.get_all_blogs()
+            blog_html = ""
+            for blog_id, blog in blogs.items():
+                author = data_store.get_user_by_id(blog["author_id"])
+                author_name = author["display_name"] if author else "Unknown"
+                blog_html += format_blog_card(blog_id, blog, author_name)
+            return blog_html
+
+        def load_recommended_blogs(user_id):
+            if not user_id:
+                return ""
+            recommended_blog_ids = ml_models.recommend_blogs(user_id)
+            recommended_html = ""
+            for blog_id in recommended_blog_ids:
+                blog = data_store.get_blog_by_id(blog_id)
+                if blog:
+                    author = data_store.get_user_by_id(blog["author_id"])
+                    author_name = author["display_name"] if author else "Unknown"
+                    recommended_html += format_blog_card(blog_id, blog, author_name, is_recommended=True)
+            return recommended_html
+
+        def view_blog(blog_id):
+            if not blog_id:
+                return "", "", "", "", ""
+            blog = data_store.get_blog_by_id(blog_id)
+            if not blog:
+                return "", "", "", "", ""
+            blog["views"] += 1
+            if data_store.current_user_id:
+                data_store.record_interaction(data_store.current_user_id, blog_id, 1)
+            author = data_store.get_user_by_id(blog["author_id"])
+            author_name = author["display_name"] if author else "Unknown"
+            comments_data = ""
+            for comment_id in blog["comments"]:
+                comment = data_store.comments.get(comment_id)
+                if comment:
+                    comment_user = data_store.get_user_by_id(comment["user_id"])
+                    user_name = comment_user["display_name"] if comment_user else "Unknown"
+                    comments_data += format_comment_card(comment, user_name)
+            return (
+                blog_id,
+                blog["title"],
+                author_name,
+                blog["content"],
+                ", ".join(blog["tags"]),
+                comments_data
+            )
+
+        def add_comment(blog_id, comment_text, user_id):
+            if not user_id:
+                return "Please log in to comment", ""
+            if not blog_id:
+                return "Please select a blog first", ""
+            moderation_result = ml_models.moderate_text(comment_text)
+            if moderation_result["is_flagged"]:
+                return "Your comment has been flagged for inappropriate content", ""
+            data_store.add_comment(blog_id, comment_text, user_id)
+            data_store.record_interaction(user_id, blog_id, 2)
+            comments_data = ""
+            blog = data_store.get_blog_by_id(blog_id)
+            for comment_id in blog["comments"]:
+                comment = data_store.comments.get(comment_id)
+                if comment:
+                    comment_user = data_store.get_user_by_id(comment["user_id"])
+                    user_name = comment_user["display_name"] if comment_user else "Unknown"
+                    comments_data += format_comment_card(comment, user_name)
+            return "Comment added successfully", comments_data
+
+        def load_user_blogs(user_id):
+            if not user_id:
+                return ""
+            user_blogs = data_store.get_user_blogs(user_id)
+            blogs_html = ""
+            for blog_id, blog in user_blogs.items():
+                author = data_store.get_user_by_id(blog["author_id"])
+                author_name = author["display_name"] if author else "Unknown"
+                blogs_html += format_blog_card(blog_id, blog, author_name)
+            return blogs_html
+
+        def create_blog(title, content, tags, user_id):
+            if not user_id:
+                return "Please log in to create a blog"
+            if not title or not content:
+                return "Title and content are required"
+            moderation_result = ml_models.moderate_text(content)
+            if moderation_result["is_flagged"]:
+                return "Your blog has been flagged for inappropriate content"
+            tag_list = [tag.strip() for tag in tags.split(",") if tag.strip()]
+            blog_id = data_store.add_blog(title, content, user_id, tag_list)
+            ml_models.update_blog_vectors()
+            return f"Blog created successfully with ID: {blog_id}"
+
+        def load_chat_rooms():
+            chat_html = ""
+            for chat_id, chat in data_store.chats.items():
+                participants = []
+                for user_id in chat["participants"]:
+                    user = data_store.get_user_by_id(user_id)
+                    if user:
+                        participants.append(user["display_name"])
+                chat_html += format_chat_room_card(chat_id, participants)
+            return chat_html
+
+        def create_chat_room(name, user_id):
+            if not user_id:
+                return "Please log in to create a chat room", ""
+            chat_id = str(uuid.uuid4())
+            data_store.chats[chat_id] = {
+                "id": chat_id,
+                "name": name,
+                "messages": [],
+                "participants": [user_id],
+                "created_at": datetime.datetime.now().isoformat()
+            }
+            return chat_id, load_chat_rooms()
+
+        def view_chat(chat_id):
+            if not chat_id:
+                return [], ""
+            chat = data_store.get_chat_by_id(chat_id)
+            if not chat:
+                return [], ""
+            messages_data = []
+            for message in chat["messages"]:
+                user = data_store.get_user_by_id(message["user_id"])
+                user_name = user["display_name"] if user else "Unknown"
+                messages_data.append([f"{user_name} ({message['created_at']})", message["content"]])
+            return messages_data, chat_id
+
+        def send_message(chat_id, message, user_id):
+            if not user_id:
+                return "Please log in to send messages", []
+            if not chat_id:
+                return "Please select a chat room first", []
+            moderation_result = ml_models.moderate_text(message)
+            if moderation_result["is_flagged"]:
+                return "Your message has been flagged for inappropriate content", []
+            data_store.add_chat_message(chat_id, message, user_id)
+            chat = data_store.get_chat_by_id(chat_id)
+            messages_data = []
+            for msg in chat["messages"]:
+                user = data_store.get_user_by_id(msg["user_id"])
+                user_name = user["display_name"] if user else "Unknown"
+                messages_data.append([f"{user_name} ({msg['created_at']})", msg["content"]])
+            return "Message sent successfully", messages_data
+
+        def load_user_profile(user_id):
+            if not user_id:
+                return "", "", "", ""
+            user = data_store.get_user_by_id(user_id)
+            if user:
+                return user["display_name"], user["email"], user["role"], ", ".join(user["badges"])
+            return "", "", "", ""
+
+        def update_profile(display_name, email, user_id):
+            if not user_id:
+                return "Please log in to update your profile"
+            user = data_store.get_user_by_id(user_id)
+            if user:
+                user["display_name"] = display_name
+                user["email"] = email
+                return "Profile updated successfully"
+            return "User not found"
+
+        def logout():
+            data_store.current_user_id = None
+            return "", gr.update(visible=True), gr.update(visible=False), "", "", "", "", "", "", ""
+
+        def refresh_content(user_id):
+            if not user_id:
+                return "", "", ""
+            return (
+                load_recommended_blogs(user_id),
+                load_user_blogs(user_id),
+                load_chat_rooms()
+            )
+
+        # JavaScript for click events
+        js_select_blog = """
+        function selectBlog(blogId) {
+            document.querySelector('input[name="blog_id"]').value = blogId;
+            document.querySelector('input[name="blog_id"]').dispatchEvent(new Event('input'));
+        }
+        """
+        js_select_chat = """
+        function selectChat(chatId) {
+            document.querySelector('input[name="chat_id"]').value = chatId;
+            document.querySelector('input[name="chat_id"]').dispatchEvent(new Event('input'));
+        }
+        """
+
+        # Hidden inputs for JavaScript events
+        blog_id_input = gr.Textbox(value="", label="Blog ID", name="blog_id", visible=False)
+        chat_id_input = gr.Textbox(value="", label="Chat ID", name="chat_id", visible=False)
+
+        # Connect events
+        login_button.click(
+            fn=login,
+            inputs=[username_input, password_input],
+            outputs=[
+                user_id_state,
+                login_status,
+                auth_group,
+                main_group,
+                recommended_blogs,
+                my_blogs_list,
+                chat_list,
+                display_name,
+                email,
+                user_role,
+                user_badges
+            ],
+            show_progress=True
+        )
+
+        blog_refresh_button.click(
+            fn=load_blogs,
+            inputs=[],
+            outputs=[blog_list],
+            show_progress=True
+        )
+
+        blog_id_input.input(
+            fn=view_blog,
+            inputs=[blog_id_input],
+            outputs=[current_blog_id, blog_title, blog_author, blog_content, blog_tags, blog_comments],
+            _js=js_select_blog
+        )
+
+        submit_comment.click(
+            fn=add_comment,
+            inputs=[current_blog_id, new_comment, user_id_state],
+            outputs=[blog_create_status, blog_comments],
+            show_progress=True
+        )
+
+        create_blog_button.click(
+            fn=create_blog,
+            inputs=[new_blog_title, new_blog_content, new_blog_tags, user_id_state],
+            outputs=[blog_create_status],
+            show_progress=True
+        )
+
+        create_chat_button.click(
+            fn=create_chat_room,
+            inputs=[new_chat_name, user_id_state],
+            outputs=[current_chat_id, chat_list],
+            show_progress=True
+        )
+
+        chat_id_input.input(
+            fn=view_chat,
+            inputs=[chat_id_input],
+            outputs=[chat_messages, current_chat_id],
+            _js=js_select_chat
+        )
+
+        send_message_button.click(
+            fn=send_message,
+            inputs=[current_chat_id, new_message, user_id_state],
+            outputs=[moderation_status, chat_messages],
+            show_progress=True
+        )
+
+        update_profile_button.click(
+            fn=update_profile,
+            inputs=[display_name, email, user_id_state],
+            outputs=[profile_update_status],
+            show_progress=True
+        )
+
+        logout_button.click(
+            fn=logout,
+            inputs=[],
+            outputs=[
+                user_id_state,
+                auth_group,
+                main_group,
+                recommended_blogs,
+                my_blogs_list,
+                chat_list,
+                display_name,
+                email,
+                user_role,
+                user_badges
+            ],
+            show_progress=True
+        )
+
+        refresh_button.click(
+            fn=refresh_content,
+            inputs=[user_id_state],
+            outputs=[recommended_blogs, my_blogs_list, chat_list],
+            show_progress=True
+        )
+
+        # Initial load
+        blog_list.value = load_blogs()
+
+    return interface
+
+# Launch the interface
+def launch_app():
+    interface = create_interface()
+    interface.launch(share=False, server_port=None)
+
+if __name__ == "__main__":
+    launch_app()