Update newweb.py

newweb.py

@@ -1,49 +1,61 @@
 from flask import Flask, render_template, request, redirect, url_for, flash, jsonify
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import select, Column, exists, or_, Table, ForeignKey, Integer, String, DateTime, Text, and_, alias
+from sqlalchemy.orm import aliased, relationship
 from flask_login import UserMixin, LoginManager, login_user, login_required, logout_user, current_user
 from flask_wtf.csrf import generate_csrf
 from werkzeug.security import generate_password_hash, check_password_hash
 from werkzeug.utils import secure_filename
 from datetime import datetime
-import sqlite3
+from flask_migrate import Migrate
 import uuid
 import os
+from sqlalchemy import or_, func
+from FastTelethonhelper import fast_download
+from FastTelethonhelper import fast_upload
+from telethon import TelegramClient, events,sync
 import asyncio
-from telethon import TelegramClient, events
-from FastTelethonhelper import fast_download, fast_upload
+import time
+
+
 
-# Configuration
 app_id = os.getenv("APP_ID")
 api_hash = os.getenv("API_HASH")
 btoken = os.getenv("BOT")
 chnl = os.getenv("CHN")
 
+
 api_id = int(app_id)
+api_hash = str(api_hash)
 bot_token = str(btoken)
-channel = int(chnl)
+channel= int(chnl)
 
-app = Flask("Simplz")
-app.config['SECRET_KEY'] = 'your_secret_key'
-app.config['UPLOAD_FOLDER'] = 'static/users/uploaded_images'
-app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'gif'}
+print('dl sec')
 
-login_manager = LoginManager(app)
-login_manager.login_view = 'login'
+###DB BACKUP##
+
+async def downdb():
+    client = TelegramClient(None, api_id, api_hash)
+    await client.start(bot_token=bot_token)
+    
+    os.remove('instance/database.db')
+    @client.on(events.NewMessage)
+    async def handler(event):
+        last_message = event.message
+        await fast_download(client,last_message)
+        await asyncio.sleep(10)
+        await client.disconnect()
+        
+
+    return '2'
 
-# Database functions
-def get_db():
-    conn = sqlite3.connect('database.db')
-    conn.row_factory = sqlite3.Row
-    return conn
 
-def close_db(conn):
-    conn.close()
 
 
 async def updb():   
     client = TelegramClient(None, api_id, api_hash)
     await client.start(bot_token=bot_token)
-    print('upldb fn')
-    path = 'database.db'
+    path = 'instance/database.db'
     fle =  await fast_upload(client, file_location=path)
     entity = await client.get_entity(channel)
 
@@ -51,39 +63,180 @@ async def updb():
     await client.disconnect()
     return '2'
 
-# User model
-class User(UserMixin):
-    def __init__(self, id, username, email, password):
-        self.id = id
-        self.username = username
-        self.email = email
-        self.password = password
+app = Flask("Simplz")
+app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.db'
+app.config['SECRET_KEY'] = 'your_secret_key'
+db = SQLAlchemy(app)
+migrate = Migrate(app, db)
+
+app.config['UPLOAD_FOLDER'] = 'static/users/uploaded_images'
+app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'gif'}
+
+followers = db.Table(
+    'followers',
+    db.Column('follower_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
+    db.Column('followed_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
+    extend_existing=True
+)
+
+class Comment(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    content = db.Column(db.Text, nullable=False)
+    timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
+    post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
+    author = db.relationship('User', backref='comments', lazy=True)
+
+
+class Like(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
+    post_id = db.Column(db.Integer, db.ForeignKey('post.id', ondelete='CASCADE'), nullable=False)
+    liked_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+
+class Follow(db.Model):
+    __tablename__ = 'followers'
+    follower_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
+    followed_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
+
+    follower = db.relationship('User', foreign_keys=[follower_id], backref='following')
+    followed = db.relationship('User', foreign_keys=[followed_id], backref='followers')
+
+    __table_args__ = {'extend_existing': True}
+
+class Message(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    sender_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
+    recipient_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
+    content = db.Column(db.Text, nullable=False)
+    timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
+    sender = db.relationship('User', foreign_keys=[sender_id], backref='sent_messages')
+    recipient = db.relationship('User', foreign_keys=[recipient_id], backref='received_messages')
+
+
+
+class User(UserMixin, db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(100), unique=True, nullable=False)
+    email = db.Column(db.String(100), unique=True, nullable=False)
+    password = db.Column(db.String(100), nullable=False)
+    first_name = db.Column(db.String(50), default="Per")
+    last_name = db.Column(db.String(50), default="Son")
+    profession = db.Column(db.String(100), default="Person")
+    location = db.Column(db.String(100), default="Earth")
+    bio = db.Column(db.Text, default="Hello there...")
+    profile_pic = db.Column(db.String(100), default='default.jpg')
+    posts = db.relationship('Post', backref='author', lazy=True)
+
+    following_list = db.relationship(
+        'User',
+        secondary=followers,
+        primaryjoin=(followers.c.follower_id == id),
+        secondaryjoin=(followers.c.followed_id == id),
+        backref=db.backref('followers_of', lazy='dynamic'),
+        lazy='dynamic',
+        overlaps="follower,followers_of,following,following_list"
+    )
+
+    followers_list = db.relationship(
+        'User',
+        secondary=followers,
+        primaryjoin=(followers.c.followed_id == id),
+        secondaryjoin=(followers.c.follower_id == id),
+        backref=db.backref('following_by', lazy='dynamic'),
+        lazy='dynamic',
+        overlaps="followed,followers,followers_of,following_list"
+    )
+
+    def is_following(self, user):
+        return self.following_list.filter_by(id=user.id).first() is not None
+
+    def follow(self, user):
+        if not self.is_following(user) and self.id != user.id:
+            self.following_list.append(user)
+            db.session.commit()
+
+    def unfollow(self, user):
+        if self.is_following(user):
+            self.following_list.remove(user)
+            db.session.commit()
+
+    def like_post(self, post):
+        if not self.has_liked_post(post):
+            like = Like(user_id=self.id, post_id=post.id)
+            db.session.add(like)
+            db.session.commit()
+
+    def unlike_post(self, post):
+        like = Like.query.filter_by(user_id=self.id, post_id=post.id).first()
+        if like:
+            db.session.delete(like)
+            db.session.commit()
+
+    def has_liked_post(self, post):
+        return Like.query.filter_by(user_id=self.id, post_id=post.id).count() > 0
+
+    def add_comment(self, post, content):
+        comment = Comment(user_id=self.id, post_id=post.id, content=content)
+        db.session.add(comment)
+        db.session.commit()
+
+    def delete_comment(self, comment):
+        if comment.user_id == self.id:
+            db.session.delete(comment)
+            db.session.commit()
+
+
+
+class Post(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    content = db.Column(db.Text, nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
+    filename = db.Column(db.String(100))
+    comments = db.relationship('Comment', backref='post', lazy=True, cascade='all, delete-orphan')
+    likes = db.relationship('Like', backref='post', lazy=True)
+    @property
+    def likes_count(self):
+        return Like.query.filter_by(post_id=self.id).count()
+
+
+login_manager = LoginManager(app)
+login_manager.login_view = 'login'
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
 
 @login_manager.user_loader
 def load_user(user_id):
-    conn = get_db()
-    user_data = conn.execute('SELECT * FROM user WHERE id = ?', (user_id,)).fetchone()
-    close_db(conn)
-    if user_data:
-        return User(user_data['id'], user_data['username'], user_data['email'], user_data['password'])
-    return None
+    return db.session.get(User, int(user_id))
+
 
 @app.route('/')
 @login_required
 def index():
-    conn = get_db()
-    posts = conn.execute('''
-        SELECT * FROM post WHERE user_id = ? 
-        UNION ALL 
-        SELECT * FROM post 
-        WHERE user_id IN (SELECT followed_id FROM followers WHERE follower_id = ?) 
-        ORDER BY created_at DESC
-    ''', (current_user.id, current_user.id)).fetchall()
-    close_db(conn)
+    followed_user = aliased(User, name='followed_user')
+    
+    own_posts_query = Post.query.filter_by(user_id=current_user.id)
     
+    followed_posts_query = Post.query.join(
+        Follow,
+        or_(
+            and_(Post.user_id == Follow.followed_id, Follow.follower_id == current_user.id),
+            and_(Post.user_id == Follow.follower_id, Follow.followed_id == current_user.id)
+        )
+    )
+
+    combined_posts_query = own_posts_query.union_all(followed_posts_query)
+    posts = combined_posts_query.order_by(Post.created_at.desc()).all()
+
     csrf_token = request.environ.get('HTTP_X_CSRFTOKEN')
+
     return render_template('index.html', posts=posts, csrf_token=csrf_token)
 
+
+
 @app.route('/register', methods=['GET', 'POST'])
 def register():
     if request.method == 'POST':
@@ -96,9 +249,8 @@ def register():
             flash('Passwords do not match. Please try again.', 'error')
             return render_template('register.html')
 
-        conn = get_db()
-        existing_user_with_username = conn.execute('SELECT * FROM user WHERE username = ?', (username,)).fetchone()
-        existing_user_with_email = conn.execute('SELECT * FROM user WHERE email = ?', (email,)).fetchone()
+        existing_user_with_username = User.query.filter_by(username=username).first()
+        existing_user_with_email = User.query.filter_by(email=email).first()
 
         if existing_user_with_username:
             flash('Username already exists. Please choose a different username.', 'error')
@@ -109,9 +261,9 @@ def register():
             return render_template('register.html')
 
         hashed_password = generate_password_hash(password, method='scrypt')
-        conn.execute('INSERT INTO user (username, email, password) VALUES (?, ?, ?)', (username, email, hashed_password))
-        conn.commit()
-        close_db(conn)
+        new_user = User(username=username, email=email, password=hashed_password)
+        db.session.add(new_user)
+        db.session.commit()
 
         flash('Account created successfully! Please log in.', 'success')
         return redirect(url_for('login'))
@@ -123,12 +275,8 @@ def login():
     if request.method == 'POST':
         username = request.form['username']
         password = request.form['password']
-        conn = get_db()
-        user_data = conn.execute('SELECT * FROM user WHERE username = ?', (username,)).fetchone()
-        close_db(conn)
-
-        if user_data and check_password_hash(user_data['password'], password):
-            user = User(user_data['id'], user_data['username'], user_data['email'], user_data['password'])
+        user = User.query.filter_by(username=username).first()
+        if user and check_password_hash(user.password, password):
             login_user(user)
             return redirect(url_for('index'))
         else:
@@ -153,37 +301,37 @@ def create_post():
     else:
         filename = None
 
-    conn = get_db()
-    conn.execute('INSERT INTO post (content, user_id, filename) VALUES (?, ?, ?)', (content, current_user.id, filename))
-    conn.commit()
-    close_db(conn)
+    new_post = Post(content=content, author=current_user, filename=filename)
+    db.session.add(new_post)
+    db.session.commit()
     return redirect(url_for('index'))
 
 @app.route('/delete_post/<int:post_id>', methods=['POST'])
 @login_required
 def delete_post(post_id):
-    conn = get_db()
-    post = conn.execute('SELECT * FROM post WHERE id = ?', (post_id,)).fetchone()
-
-    if post and post['user_id'] == current_user.id:
-        if post['filename']:
-            try:
-                os.remove(os.path.join(app.config['UPLOAD_FOLDER'], post['filename']))
-            except Exception as e:
-                flash(f"Error deleting image file: {str(e)}", "error")
-
-        conn.execute('DELETE FROM post WHERE id = ?', (post_id,))
-        conn.execute('DELETE FROM like WHERE post_id = ?', (post_id,))
-        conn.commit()
-    close_db(conn)
+    post = db.session.get(Post, post_id)
+    if post and post.author == current_user:
+        if post.filename:
+             try:
+                 os.remove(os.path.join(app.config['UPLOAD_FOLDER'], post.filename))
+             except Exception as e:
+                 flash(f"Error deleting image file: {str(e)}", "error")
+        
+       
+        Like.query.filter_by(post_id=post_id).delete()
+        db.session.delete(post)
+        db.session.commit()
     return redirect(url_for('index'))
 
+
+
+
+
 @app.route('/follow/<int:user_id>', methods=['POST'])
 @login_required
 def follow(user_id):
-    conn = get_db()
-    user_to_follow = conn.execute('SELECT * FROM user WHERE id = ?', (user_id,)).fetchone()
-
+    
+    user_to_follow = User.query.get(user_id)
     if user_to_follow is None:
         flash('User not found.', 'error')
         return redirect(url_for('explore'))
@@ -193,36 +341,175 @@ def follow(user_id):
         return redirect(url_for('view_profile', user_id=user_id))
 
     try:
-        conn.execute('INSERT INTO followers (follower_id, followed_id) VALUES (?, ?)', (current_user.id, user_id))
-        conn.commit()
+        current_user.follow(user_to_follow)
     except Exception as e:
         flash('Failed to follow the user. Please try again.', 'error')
         print(f"Error: {str(e)}")
         return redirect(url_for('view_profile', user_id=user_id))
 
-    flash(f"You are now following {user_to_follow['username']}.", 'success')
-    close_db(conn)
+    flash(f"You are now following {user_to_follow.username}.", 'success')
     return redirect(url_for('view_profile', user_id=user_id))
 
+
 @app.route('/unfollow/<int:user_id>', methods=['POST'])
 @login_required
-def unfollow(user_id):
-    conn = get_db()
-    user_to_unfollow = conn.execute('SELECT * FROM user WHERE id = ?', (user_id,)).fetchone()
-
+def unfollow(user_id, page):
+    user_to_unfollow = User.query.get(user_id)
     if user_to_unfollow is None:
         flash('User not found.', 'danger')
         return redirect(url_for('index'))
 
     if current_user.is_following(user_to_unfollow):
-        conn.execute('DELETE FROM followers WHERE follower_id = ? AND followed_id = ?', (current_user.id, user_id))
-        conn.commit()
-        flash('You have unfollowed {}.'.format(user_to_unfollow['username']), 'success')
+        current_user.unfollow(user_to_unfollow)
+        flash('You have unfollowed {}.'.format(user_to_unfollow.username), 'success')
     else:
         flash('You are not following this user.', 'info')
+    if page == 'profile':
+        return redirect(url_for('view_profile', user_id=user_id))
+    elif page == 'search':
+        return redirect(url_for('search_results', query=request.form['query']))
+    else:
+        return redirect(url_for('view_profile', user_id=user_id))
+
+
+@app.route('/account', methods=['GET', 'POST'])
+@login_required
+def account():
+    if request.method == 'POST':
+        current_user.username = request.form['username']
+        current_user.email = request.form['email']
+        current_user.first_name = request.form['first_name']
+        current_user.last_name = request.form['last_name']
+        current_user.bio = request.form['bio']
+        current_user.location = request.form['location']
+        current_user.profession = request.form['profession']
+
+        profile_picture = request.files['profile_picture']
+        if profile_picture and allowed_file(profile_picture.filename):
+            filename = str(uuid.uuid4()) + secure_filename(profile_picture.filename)
+            profile_picture.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
+
+            if current_user.profile_pic is not None and current_user.profile_pic != 'default.jpg':
+                old_profile_picture_path = os.path.join(app.config['UPLOAD_FOLDER'], current_user.profile_pic)
+                os.remove(old_profile_picture_path)
+
+            current_user.profile_pic = filename
+
+        new_password = request.form['new_password']
+        if new_password:
+            current_user.password = generate_password_hash(new_password, method='scrypt')
+
+        db.session.commit()
+        flash('Profile updated successfully!', 'success')
+        return redirect(url_for('account'))
+
+    return render_template('account.html')
+
+@app.route('/search_user', methods=['GET'])
+def search_user():
+    search_query = request.args.get('search_query', '')
+    users = User.query.filter(
+        
+        or_(
+        User.username.ilike(f'%{search_query}%'),
+        User.first_name.ilike(f'%{search_query}%'),
+        User.last_name.ilike(f'%{search_query}%'),
+        (User.first_name + User.last_name).like(f'%{search_query}%')
+        )
+              ).all()
+
+
+    #users = User.query.filter(User.username.ilike(f'%{search_query}%')).all()
+    csrf_token = generate_csrf()  # Generate CSRF token
+    return render_template('search_results.html', users=users, csrf_token=csrf_token, searchq=search_query )
+
+@app.route('/user/<int:user_id>')
+@login_required
+def view_profile(user_id):
+    user = User.query.get(user_id)
+    if not user:
+        flash('User not found.', 'error')
+        return redirect(url_for('search_user'))
+
+    posts = Post.query.filter_by(user_id=user.id).order_by(Post.created_at.desc()).all()
+    csrf_token = generate_csrf()
+    return render_template('user_profile.html', user=user, posts=posts, csrf_token=csrf_token, profile_user_id=user_id)
+
+@app.route('/add_comment/<int:post_id>', methods=['POST'])
+@login_required
+def add_comment(post_id):
+    content = request.form['content']
+    post = Post.query.get(post_id)
+    if not post:
+        flash('Post not found.', 'error')
+        return redirect(url_for('index'))
+    current_user.add_comment(post, content)
+
+    flash('Comment added successfully.', 'success')
+    return redirect(url_for('index'))
+
+@login_required
+@app.route('/like_post/<int:post_id>', methods=['POST'])
+def like_post(post_id):
+    post = Post.query.get(post_id)
+    if not post:
+        flash('Post not found.', 'error')
+        return redirect(url_for('index'))
+
+    if current_user.has_liked_post(post):
+        current_user.unlike_post(post)
+        db.session.commit()
+        liked = False
+    else:
+        current_user.like_post(post)
+        db.session.commit()
+        liked = True
+
+    likes_count = post.likes_count
+    response_data = {'likes_count': likes_count, 'liked': liked}
+    return jsonify(response_data)
+
+
+@app.route('/send_message', methods=['POST'])
+@login_required
+def send_message():
+    recipient_username = request.form['recipient_username']
+    message_content = request.form['message_content']
+
+    recipient = User.query.filter_by(username=recipient_username).first()
+    if not recipient:
+        flash('Recipient not found.', 'error')
+        return redirect(url_for('conversations'))
+
+    new_message = Message(sender_id=current_user.id, recipient_id=recipient.id, content=message_content)
+    db.session.add(new_message)
+    db.session.commit()
+
+    flash('Message sent successfully!', 'success')
+    return redirect(url_for('conversation', recipient_id=recipient.id))
+
+
+@app.route('/conversations')
+@login_required
+def conversations():
+    conversations = db.session.query(User).join(
+        Message, or_(
+            and_(Message.sender_id == current_user.id, Message.recipient_id == User.id),
+            and_(Message.sender_id == User.id, Message.recipient_id == current_user.id)
+        )
+    ).distinct(User.id).all()
+
+    return render_template('conversations.html', conversations=conversations)
+
+@app.route('/new_conversation', methods=['GET'])
+@login_required
+def new_conversation():
+    return render_template('new_conversation.html')
+
+
+
+
 
-    close_db(conn)
-    return redirect(url_for('view_profile', user_id=user_id))
 
 
 @app.route('/updb', methods=['GET'])
@@ -233,7 +520,7 @@ def updbur():
     asyncio.set_event_loop(loop)
     
     # Run the async function
-   
+    session.close()
     rp = loop.run_until_complete(updb())
     loop.close()  # Close the loop when done
     
@@ -242,53 +529,39 @@ def updbur():
     return 'no'
 
 
-@app.route('/search_user', methods=['GET'])
-def search_user():
-    search_query = request.args.get('search_query', '')
-    conn = get_db()
-    users = conn.execute('''
-        SELECT * FROM user 
-        WHERE username LIKE ? OR first_name LIKE ? OR last_name LIKE ?
-    ''', (f'%{search_query}%', f'%{search_query}%', f'%{search_query}%')).fetchall()
-    close_db(conn)
 
-    csrf_token = generate_csrf()
-    return render_template('search_results.html', users=users, csrf_token=csrf_token, searchq=search_query)
 
-# Other routes and functions remain mostly unchanged
+@app.route('/conversation/<int:recipient_id>', methods=['GET', 'POST'])
+@login_required
+def conversation(recipient_id):
+    recipient = User.query.get(recipient_id)
+    if not recipient:
+        flash('Recipient not found.', 'error')
+        return redirect(url_for('conversations'))
+
+    if request.method == 'POST':
+        message_content = request.form['message_content']
+
+        new_message = Message(sender_id=current_user.id, recipient_id=recipient.id, content=message_content)
+        db.session.add(new_message)
+        db.session.commit()
+
+        flash('Message sent successfully!', 'success')
+        return redirect(url_for('conversation', recipient_id=recipient_id))
+
+    messages = Message.query.filter(or_(
+        and_(Message.sender_id == current_user.id, Message.recipient_id == recipient_id),
+        and_(Message.sender_id == recipient_id, Message.recipient_id == current_user.id)
+    )).order_by(Message.timestamp).all()
+
+    return render_template('conversation.html', recipient=recipient, messages=messages)
+
+
 
 def start_flask_app():
     with app.app_context():
-        # Ensure database and tables exist
-        conn = get_db()
-        conn.execute('''CREATE TABLE IF NOT EXISTS user (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            username TEXT UNIQUE,
-            email TEXT UNIQUE,
-            password TEXT
-        )''')
-
-        conn.execute('''CREATE TABLE IF NOT EXISTS post (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            content TEXT,
-            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-            user_id INTEGER,
-            filename TEXT,
-            FOREIGN KEY (user_id) REFERENCES user (id)
-        )''')
-
-        conn.execute('''CREATE TABLE IF NOT EXISTS followers (
-            follower_id INTEGER,
-            followed_id INTEGER,
-            PRIMARY KEY (follower_id, followed_id),
-            FOREIGN KEY (follower_id) REFERENCES user (id),
-            FOREIGN KEY (followed_id) REFERENCES user (id)
-        )''')
-        
-        close_db(conn)
-    
+        db.create_all()
     app.run(debug=True, use_reloader=False, host="0.0.0.0", port=7860)
 
-
 if __name__ == '__main__':
-    start_flask_app()
+    start_flask_app()