Upload 6 files

.gitattributes

@@ -0,0 +1 @@
+logo.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+FROM python:3.10
+RUN apt-get update && apt-get install -y ffmpeg
+COPY requirements.txt .
+RUN apt-get update && apt-get install -y \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,389 @@
+import os
+os.environ["NUMBA_CACHE_DIR"] = "/tmp/numba_cache"
+os.environ["NUMBA_DISABLE_JIT"] = "1"
+from apscheduler.schedulers.background import BackgroundScheduler
+import requests
+import time
+import logging
+from flask import Flask, request, jsonify, send_file
+from flask_cors import CORS
+from predict import handle_predict
+from database import (
+    init_db, save_prediction, get_history, register_user, authenticate_user,
+    get_user_profile, update_user_profile, get_farm_details_from_db, 
+    update_farm_details_in_db, get_farm_detailss_from_db, get_hives_from_db, 
+    get_hive_detail_from_db, add_hive_to_db, delete_hive_from_db, update_hive_health_in_db,
+    add_task_to_db, get_user_tasks_from_db, get_task_detail_from_db, 
+    delete_task_from_db, update_task_status_to_completed, update_hive_in_db,
+    generate_reset_code, verify_reset_code, update_user_password, change_user_password, get_all_notifications, add_notification, 
+    mark_notification_as_read, get_user_cities
+)
+from forget import forgot_password, verify_reset_code_endpoint, reset_password
+from report import generate_report
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+app.secret_key = os.urandom(24)
+CORS(app)
+
+# Forgot password endpoint
+@app.route('/forgot_password', methods=['POST'])
+def forgot_password_endpoint():
+    return forgot_password(request)
+
+# Verify reset code endpoint
+@app.route('/verify_reset_code', methods=['POST'])
+def verify_reset_code_route():
+    return verify_reset_code_endpoint(request)
+
+# Reset password endpoint
+@app.route('/reset_password', methods=['POST'])
+def reset_password_endpoint():
+    return reset_password(request)
+
+@app.route('/change_password', methods=['POST'])
+def change_password():
+    data = request.json
+    user_id = data.get('user_id')
+    current_password = data.get('password')
+    new_password = data.get('new_password')
+    
+    if not all([user_id, current_password, new_password]):
+        return jsonify({"error": "Missing required fields"}), 400
+    
+    result = change_user_password(user_id, current_password, new_password)
+    if result:
+        return jsonify({"message": "Password changed successfully"}), 200
+    return jsonify({"error": "Current password incorrect"}), 401
+
+# Existing endpoints (unchanged)
+@app.route('/predict', methods=['POST'])
+def predict():
+    return handle_predict(request, save_prediction)
+
+@app.route('/signup', methods=['POST'])
+def signup():
+    data = request.json
+    result = register_user(data['fullName'], data['email'], data['password'])
+    if result == "email already exist":
+        return jsonify({"message": result}), 215
+    return jsonify({"message": result}), 200
+
+@app.route('/login', methods=['POST'])
+def login():
+    data = request.json
+    result = authenticate_user(data['email'], data['password'])
+    if "error" in result:
+        return jsonify(result), 415
+    return jsonify(result), 200
+
+@app.route('/profile', methods=['GET'])
+def profile():
+    user_id = request.args.get('user_id')
+    return jsonify(get_user_profile(user_id))
+
+@app.route('/profile/update', methods=['POST'])
+def update_profile():
+    data = request.json
+    return jsonify(update_user_profile(
+        data['user_id'], data['fullname'], data['country'], data['city'], 
+        data['gender'], data['phone_number']
+    ))
+
+@app.route('/history', methods=['GET'])
+def history():
+    user_id = request.args.get('user_id')
+    return jsonify({"history": get_history(user_id)})
+
+@app.route('/farm', methods=['GET'])
+def get_farm_details():
+    user_id = request.args.get('user_id')
+    if not user_id:
+        return jsonify({"error": "User ID is required"}), 400
+    farm = get_farm_details_from_db(user_id)
+    return jsonify(farm) if farm else jsonify({"error": "Farm details not found"}), 404
+
+@app.route('/farm/update', methods=['POST'])
+def update_farm():
+    data = request.json
+    return jsonify(update_farm_details_in_db(
+        data['user_id'], data['fullname'], data['country'], data['city'], data['zip']
+    ))
+
+@app.route('/farms', methods=['GET'])
+def get_farm():
+    user_id = request.args.get('user_id')
+    if not user_id:
+        return jsonify({"error": "User ID is required"}), 400
+    farm = get_farm_details_from_db(user_id)
+    return jsonify(farm) if farm else jsonify({"error": "No farm registered"}), 404
+
+@app.route('/hives', methods=['GET'])
+def get_hives():
+    farm_id = request.args.get('farm_id')
+    if not farm_id:
+        return jsonify({"error": "Farm ID is required"}), 400
+    hives = get_hives_from_db(farm_id)
+    return jsonify(hives)
+
+@app.route('/hives', methods=['POST'])
+def add_hive():
+    data = request.json
+    if not all(key in data for key in ['farm_id', 'hive_number', 'bee_type', 'number_of_frames', 'health_status']):
+        return jsonify({"error": "Missing required fields"}), 400
+    try:
+        hive_id = add_hive_to_db(
+            data['farm_id'],
+            data['hive_number'],
+            data['bee_type'],
+            data['number_of_frames'],
+            data['health_status'],
+            data.get('notes', '')
+        )
+        return jsonify({"success": True, "hive_id": hive_id}), 201
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/hives', methods=['DELETE'])
+def delete_hive():
+    hive_id = request.args.get('hive_id')
+    if not hive_id:
+        return jsonify({"error": "Hive ID is required"}), 400
+    try:
+        deleted = delete_hive_from_db(hive_id)
+        if deleted:
+            return jsonify({"success": True}), 200
+        else:
+            return jsonify({"error": "Hive not found"}), 404
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/hive_detail', methods=['GET'])
+def get_hives_detail():
+    hive_id = request.args.get('hive_id')
+    if not hive_id:
+        return jsonify({"error": "Hive Id is required"}), 400
+    hivess = get_hive_detail_from_db(hive_id)
+    return jsonify(hivess)
+
+@app.route('/manual_health_update', methods=['POST'])
+def update_hive_health():
+    data = request.json
+    if not all(key in data for key in ['hive_id', 'health_status']):
+        return jsonify({"error": "Missing required fields"}), 400
+    try:
+        update_hive_health_in_db(data['hive_id'], data['health_status'])
+        return jsonify({"success": True, "message": "Health status updated"}), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/edit_hive', methods=['POST'])
+def update_hive():
+    data = request.json
+    if 'hive_id' not in data:
+        return jsonify({"error": "hive_id is required"}), 400
+    update_data = {k: v for k, v in data.items() if k in {'hive_id', 'number_of_frames', 'bee_type', 'notes'}}
+    if len(update_data) <= 1:
+        return jsonify({"error": "No valid fields provided"}), 400
+    try:
+        result = update_hive_in_db(
+            update_data['hive_id'],
+            update_data.get('number_of_frames'),
+            update_data.get('bee_type'),
+            update_data.get('notes')
+        )
+        if not result:
+            return jsonify({"error": "Hive not found"}), 404
+        return jsonify({"success": True, "hive_id": update_data['hive_id']}), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/report', methods=['GET'])
+def get_report():
+    user_id = request.args.get('user_id')
+    if not user_id:
+        return jsonify({"error": "User ID is required"}), 400
+    try:
+        buffer = generate_report(user_id)
+        buffer.seek(0)
+        return send_file(
+            buffer,
+            as_attachment=True,
+            download_name=f"bee_hive_report_{user_id}_{datetime.now().strftime('%Y%m%d')}.pdf",
+            mimetype='application/pdf'
+        )
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/addtask', methods=['POST'])
+def add_task():
+    data = request.json
+    required_fields = ['user_id', 'task_name', 'description', 'deadline_date', 'status']
+    if not all(key in data for key in required_fields):
+        return jsonify({"error": "Missing required fields"}), 400
+    try:
+        task_id = add_task_to_db(
+            data['user_id'],
+            data['task_name'],
+            data.get('hive_id'),
+            data['description'],
+            data['deadline_date'],
+            data['status']
+        )
+        return jsonify({"success": True, "task_id": task_id}), 201
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/showtasks', methods=['GET'])
+def get_user_tasks():
+    user_id = request.args.get('user_id')
+    if not user_id:
+        return jsonify({"error": "User ID is required"}), 400
+    try:
+        tasks = get_user_tasks_from_db(user_id)
+        return jsonify({"tasks": tasks}), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/task_detail', methods=['GET'])
+def get_task_detail():
+    task_id = request.args.get('task_id')
+    if not task_id:
+        return jsonify({"error": "Task ID is required"}), 400
+    try:
+        task = get_task_detail_from_db(task_id)
+        if task:
+            return jsonify(task), 200
+        return jsonify({"error": "Task not found"}), 404
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/task_complete', methods=['POST'])
+def mark_task_complete():
+    data = request.json
+    task_id = data.get('task_id')
+    if not task_id:
+        return jsonify({"error": "Task ID is required"}), 400
+    try:
+        updated = update_task_status_to_completed(task_id)
+        if updated:
+            return jsonify({"success": True, "message": "Task marked as completed"}), 200
+        return jsonify({"error": "Task not found"}), 404
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/delete_task', methods=['DELETE'])
+def delete_task():
+    data = request.get_json()
+    task_id = data.get("task_id") if data else None
+    if not task_id:
+        return jsonify({"error": "Task ID is required"}), 400
+    try:
+        deleted = delete_task_from_db(task_id)
+        if deleted:
+            return jsonify({"success": True}), 200
+        else:
+            return jsonify({"error": "Task not found"}), 404
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/notifications', methods=['GET'])
+def get_notifications():
+    user_id = request.args.get('user_id')
+    if not user_id:
+        return jsonify({"error": "User ID is required"}), 400
+    try:
+        notifications = get_all_notifications(user_id)
+        return jsonify({"notifications": notifications}), 200
+    except TypeError as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/notifications/mark_read', methods=['POST'])
+def mark_notifications_read():
+    data = request.json
+    notification_id = data.get('notification_id')
+    if not notification_id:
+        return jsonify({"error": "Notification ID is required"}), 400
+    try:
+        mark_notification_as_read(notification_id)
+        return jsonify({"message": "Notification marked as read"}), 200
+    except Exception as e:
+        return jsonify({"error)": str(e)}), 500
+
+@app.route('/add_notifications', methods=['POST'])
+def create_notification():
+    data = request.json
+    required_fields = ['user_id', 'textt']
+    if not all(key in data for key in required_fields):
+        return jsonify({"error": "Missing required fields"}), 400
+    try:
+        notification_id = add_notification(
+            data['user_id'],
+            data['textt']
+        )
+        return jsonify({"success": True, "notification_id": notification_id}), 201
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/check_weather', methods=['POST'])
+def trigger_weather_check():
+    try:
+        check_weather_conditions()
+        return jsonify({"message": "Weather check triggered successfully"}), 200
+    except Exception as e:
+        logger.error(f"Error triggering weather check: {str(e)}")
+        return jsonify({"error": str(e)}), 500
+
+def check_weather_conditions():
+    logger.info("Checking weather conditions for users")
+    # Wake up the database
+    try:
+        response = requests.get("https://bilalhasanniazi-bee-notbee.hf.space/profile?user_id=0")
+        if response.status_code == 200:
+            logger.info("Database wake-up API called successfully")
+        else:
+            logger.warning(f"Database wake-up API failed with status {response.status_code}")
+    except Exception as e:
+        logger.error(f"Error calling database wake-up API: {str(e)}")
+    
+    # Wait for 10 seconds
+    time.sleep(10)
+    
+    user_cities = get_user_cities()
+    weather_api_key = "9fb23a5a66764b61a43163911251605"
+    base_url = "http://api.weatherapi.com/v1/forecast.json"
+
+    for user_id, city in user_cities.items():
+        try:
+            # Fetch weather data
+            response = requests.get(f"{base_url}?key={weather_api_key}&q={city}")
+            if response.status_code != 200:
+                logger.warning(f"Failed to fetch weather for city {city}: {response.status_code}")
+                continue
+
+            data = response.json()
+            if "error" in data:
+                logger.warning(f"Invalid city {city} for user {user_id}: {data['error']['message']}")
+                continue
+
+            temp_c = data["current"]["temp_c"]
+            if temp_c > 45:
+                notification_text = "Temperature is too hot, take safety precautions to protect bees"
+                add_notification(user_id, notification_text)
+                logger.info(f"Notification added for user {user_id} in {city}: {notification_text}")
+
+        except Exception as e:
+            logger.error(f"Error processing weather for user {user_id}, city {city}: {str(e)}")
+
+# Initialize scheduler
+scheduler = BackgroundScheduler()
+scheduler.add_job(check_weather_conditions, 'interval', hours=24)
+scheduler.start()
+
+if __name__ == '__main__':
+    logger.info("Starting Flask application")
+    app.run(debug=False, host='0.0.0.0', port=7860)

config.json

@@ -0,0 +1,23 @@
+{
+  "_name_or_path": "google/vit-base-patch16-224-in21k",
+  "architectures": [
+    "ViTForImageClassification"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "encoder_stride": 16,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 768,
+  "image_size": 224,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "model_type": "vit",
+  "num_attention_heads": 12,
+  "num_channels": 3,
+  "num_hidden_layers": 12,
+  "patch_size": 16,
+  "qkv_bias": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.47.0"
+}

database.py

@@ -0,0 +1,603 @@
+import psycopg2
+from psycopg2 import pool
+from datetime import datetime, timedelta
+import os
+import json
+import secrets
+import time
+from functools import wraps
+
+# Load and parse DATABASE_CONFIG from environment variable
+database_config_json = os.getenv("neon_db")
+DB_CONFIG = json.loads(database_config_json)
+
+# Initialize connection pool
+db_pool = psycopg2.pool.SimpleConnectionPool(1, 20, **DB_CONFIG)
+
+# Retry decorator for handling EOF errors
+def retry_on_eof(max_attempts=2, delay=3):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            attempts = 0
+            while attempts < max_attempts:
+                try:
+                    return func(*args, **kwargs)
+                except psycopg2.OperationalError as e:
+                    if "SSL SYSCALL error: EOF detected" in str(e):
+                        print(f"EOF detected in {func.__name__}, retrying {attempts + 1}/{max_attempts} after {delay}s")
+                        attempts += 1
+                        if attempts == max_attempts:
+                            raise  # Re-raise the exception if max attempts reached
+                        time.sleep(delay)  # Wait before retrying
+                        # Re-establish connection if closed
+                        conn = db_pool.getconn()
+                        if conn.closed:
+                            db_pool.putconn(conn, close=True)
+                            conn = db_pool.getconn()
+                    else:
+                        raise  # Re-raise other OperationalErrors
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+@retry_on_eof(max_attempts=2, delay=3)
+def init_db():
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("CREATE TABLE IF NOT EXISTS users (user_id SERIAL PRIMARY KEY, email TEXT UNIQUE, password TEXT)")
+            c.execute("""
+                CREATE TABLE IF NOT EXISTS predictions (
+                    pred_id SERIAL PRIMARY KEY,
+                    user_id INT,
+                    timestamp TEXT,
+                    audio_name TEXT,
+                    result TEXT,
+                    audio BYTEA,
+                    hive_id INT,
+                    FOREIGN KEY (hive_id) REFERENCES Hive(hive_id)
+                )
+            """)
+            c.execute("CREATE TABLE IF NOT EXISTS farm (farm_id SERIAL PRIMARY KEY, user_id INT UNIQUE, fullname TEXT, country TEXT, city TEXT, zip TEXT, hives INT DEFAULT 0)")
+            c.execute("""
+                CREATE TABLE IF NOT EXISTS Hive (
+                    hive_id SERIAL PRIMARY KEY,
+                    farm_id INT,
+                    hive_number INT,
+                    bee_type TEXT,
+                    number_of_frames INT,
+                    creation_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    health_status TEXT,
+                    notes TEXT,
+                    FOREIGN KEY (farm_id) REFERENCES farm(farm_id)
+                )
+            """)
+            conn.commit()
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def generate_reset_code(email):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            # Check if email exists
+            c.execute("SELECT user_id FROM users WHERE email = %s", (email,))
+            user = c.fetchone()
+            if not user:
+                return None
+            # Generate 6-digit code
+            code = ''.join(str(secrets.randbelow(10)) for _ in range(6))
+            # Set expiration (15 minutes from now)
+            expires_at = datetime.now() + timedelta(minutes=15)
+            # Store code
+            c.execute(
+                """
+                INSERT INTO password_reset_codes (user_id, code, expires_at)
+                VALUES (%s, %s, %s)
+                ON CONFLICT (user_id) DO UPDATE
+                SET code = %s, expires_at = %s
+                """,
+                (user[0], code, expires_at, code, expires_at)
+            )
+            conn.commit()
+        return code
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def verify_reset_code(email, code):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute(
+                """
+                SELECT code, expires_at
+                FROM password_reset_codes prc
+                JOIN users u ON prc.user_id = u.user_id
+                WHERE u.email = %s AND prc.code = %s
+                """,
+                (email, code)
+            )
+            result = c.fetchone()
+            if result and result[1] > datetime.now():
+                # Delete code after verification
+                c.execute("DELETE FROM password_reset_codes WHERE code = %s", (code,))
+                conn.commit()
+                return True
+            return False
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def update_user_password(email, new_password):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute(
+                "UPDATE users SET password = %s WHERE email = %s RETURNING user_id",
+                (new_password, email)
+            )
+            result = c.fetchone()
+            conn.commit()
+        return bool(result)
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def change_user_password(user_id, current_password, new_password):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            # Verify user exists and current password matches
+            c.execute(
+                "SELECT user_id FROM users WHERE user_id = %s AND password = %s",
+                (user_id, current_password)
+            )
+            user = c.fetchone()
+            if not user:
+                return False
+                
+            # Update password
+            c.execute(
+                "UPDATE users SET password = %s WHERE user_id = %s",
+                (new_password, user_id)
+            )
+            conn.commit()
+            return True
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def add_hive_to_db(farm_id, hive_number, bee_type, number_of_frames, health_status, notes):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                INSERT INTO Hive (farm_id, hive_number, bee_type, number_of_frames, health_status, notes)
+                VALUES (%s, %s, %s, %s, %s, %s)
+                RETURNING hive_id
+            """, (farm_id, hive_number, bee_type, number_of_frames, health_status, notes))
+            hive_id = c.fetchone()[0]
+            c.execute("UPDATE farm SET hives = hives + 1 WHERE farm_id = %s", (farm_id,))
+            conn.commit()
+            return hive_id
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def delete_hive_from_db(hive_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("SELECT farm_id FROM Hive WHERE hive_id = %s", (hive_id,))
+            farm = c.fetchone()
+            if farm:
+                farm_id = farm[0]
+                c.execute("DELETE FROM Hive WHERE hive_id = %s", (hive_id,))
+                if c.rowcount > 0:
+                    c.execute("UPDATE farm SET hives = hives - 1 WHERE farm_id = %s", (farm_id,))
+                    conn.commit()
+                    return True
+            return False
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def register_user(fullname, email, password=None, google_id=None):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            # Check if email or google_id already exists
+            c.execute("SELECT email, google_id FROM users WHERE email = %s OR google_id = %s", (email, google_id))
+            if c.fetchone():
+                return "email already exist"
+            
+            # Insert new user with default values
+            c.execute(
+                "INSERT INTO users (fullname, email, password, google_id, country, city, gender, phone_number) VALUES (%s, %s, %s, %s, %s, %s, %s, %s) RETURNING user_id",
+                (fullname, email, password, google_id, "Pakistan", "Karachi", "Male", "0")
+            )
+            user_id = c.fetchone()[0]
+            
+            # Create farm record for the new user with default values
+            c.execute(
+                "INSERT INTO farm (user_id, fullname, country, city, zip, hives) VALUES (%s, %s, %s, %s, %s, %s)",
+                (user_id, "user farm", "Pakistan", "Karachi", "24700", 0)
+            )
+            
+            conn.commit()
+        return "Signup successful"
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def authenticate_google_user(google_id, email):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            # Get user_id and farm_id by google_id or email
+            c.execute("""
+                SELECT u.user_id, f.farm_id 
+                FROM users u 
+                LEFT JOIN farm f ON u.user_id = f.user_id 
+                WHERE u.google_id = %s OR u.email = %s
+            """, (google_id, email))
+            result = c.fetchone()
+            return {"user_id": result[0], "farm_id": result[1]} if result else {"error": "User not found"}
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def authenticate_user(email, password):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            # Get user_id and farm_id
+            c.execute("""
+                SELECT u.user_id, f.farm_id 
+                FROM users u 
+                LEFT JOIN farm f ON u.user_id = f.user_id 
+                WHERE u.email = %s AND u.password = %s
+            """, (email, password))
+            result = c.fetchone()
+            return {"user_id": result[0], "farm_id": result[1]} if result else {"error": "Invalid credentials"}
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def save_prediction(user_id, audio_name, result, file_id, hive_id=None, user_predict=None):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            # Add 5 hours to server time
+            timestamp = (datetime.now() + timedelta(hours=5)).strftime("%Y-%m-%d %H:%M:%S")
+            c.execute(
+                "INSERT INTO predictions (user_id, timestamp, audio_name, result, file_id, hive_id, user_predict) "
+                "VALUES (%s, %s, %s, %s, %s, %s, %s)",
+                (user_id, timestamp, audio_name, result, file_id, hive_id, user_predict)
+            )
+            conn.commit()
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_history(user_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                SELECT p.timestamp, p.audio_name, p.result, p.hive_id, h.hive_number
+                FROM predictions p
+                LEFT JOIN Hive h ON p.hive_id = h.hive_id
+                WHERE p.user_id = %s
+                ORDER BY p.timestamp DESC
+            """, (user_id,))
+            return [{
+                "timestamp": row[0],
+                "audio_name": row[1],
+                "result": row[2],
+                "hive_number": row[4] if row[3] else None
+            } for row in c.fetchall()]
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_user_profile(user_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("SELECT email, fullname, country, city, gender, phone_number FROM users WHERE user_id = %s", (user_id,))
+            user = c.fetchone()
+            return {
+                "email": user[0], "fullname": user[1], "country": user[2], 
+                "city": user[3], "gender": user[4], "phone_number": user[5]
+            } if user else {"error": "User not found"}
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def update_user_profile(user_id, fullname, country, city, gender, phone_number):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                UPDATE users 
+                SET fullname = %s, country = %s, city = %s, gender = %s, phone_number = %s 
+                WHERE user_id = %s
+            """, (fullname, country, city, gender, phone_number, user_id))
+            conn.commit()
+        return {"message": "Profile updated successfully"}
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_farm_details_from_db(user_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("SELECT farm_id, fullname, country, city, zip, hives FROM farm WHERE user_id = %s", (user_id,))
+            farm = c.fetchone()
+            return {
+                "farm_id": farm[0],
+                "fullname": farm[1],
+                "country": farm[2],
+                "city": farm[3],
+                "zip": farm[4]
+            } if farm else None
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def update_farm_details_in_db(user_id, fullname, country, city, zip_code):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("SELECT farm_id FROM farm WHERE user_id = %s", (user_id,))
+            existing_farm = c.fetchone()
+
+            if existing_farm:
+                c.execute("""
+                    UPDATE farm 
+                    SET fullname = %s, country = %s, city = %s, zip = %s 
+                    WHERE user_id = %s
+                """, (fullname, country, city, zip_code, user_id))
+            else:
+                c.execute("""
+                    INSERT INTO farm (user_id, fullname, country, city, zip) 
+                    VALUES (%s, %s, %s, %s, %s)
+                """, (user_id, fullname, country, city, zip_code))
+
+            conn.commit()
+        return {"message": "Farm details updated successfully"}
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_farm_detailss_from_db(user_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("SELECT farm_id FROM farm WHERE user_id = %s", (user_id,))
+            farm = c.fetchone()
+            return {"farm_id": farm[0]} if farm else None
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_hives_from_db(farm_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("SELECT hive_id, hive_number, health_status FROM Hive WHERE farm_id = %s ORDER BY hive_number", (farm_id,))
+            return [{"hive_id": row[0], "hive_number": row[1], "health_status": row[2]} for row in c.fetchall()]
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_hive_detail_from_db(hive_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute(
+                "SELECT hive_number, bee_type, number_of_frames, creation_date, health_status, notes FROM Hive WHERE hive_id = %s",
+                (hive_id,)
+            )
+            row = c.fetchone()
+            if row:
+                return {
+                    "hive_number": row[0],
+                    "bee_type": row[1],
+                    "number_of_frames": row[2],
+                    "creation_date": row[3],
+                    "health_status": row[4],
+                    "notes": row[5]
+                }
+            return {"error": "Hive not found"}
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def update_hive_health_in_db(hive_id, health_status):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("UPDATE hive SET health_status = %s WHERE hive_id = %s", (health_status, hive_id))
+            if c.rowcount == 0:
+                raise Exception("Hive not found")
+            conn.commit()
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def update_hive_in_db(hive_id, number_of_frames, bee_type, notes):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute(
+                """
+                UPDATE Hive
+                SET number_of_frames = %s, bee_type = %s, notes = %s
+                WHERE hive_id = %s
+                RETURNING hive_id
+                """,
+                (number_of_frames, bee_type, notes, hive_id)
+            )
+            result = c.fetchone()
+            conn.commit()
+        return bool(result)
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def add_task_to_db(user_id, task_name, hive_id, description, deadline_date, status):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                INSERT INTO Task (user_id, task_name, hive_id, description, deadline_date, status)
+                VALUES (%s, %s, %s, %s, %s, %s)
+                RETURNING task_id
+            """, (user_id, task_name, None if hive_id is None else hive_id, description, deadline_date, status))
+            task_id = c.fetchone()[0]
+            conn.commit()
+            return task_id
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_user_tasks_from_db(user_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                SELECT task_id, task_name, status, deadline_date
+                FROM Task
+                WHERE user_id = %s
+                ORDER BY status = 'pending' DESC, deadline_date ASC NULLS LAST, task_id
+            """, (user_id,))
+            return [{
+                "task_id": row[0],
+                "task_name": row[1],
+                "status": row[2],
+                "deadline_date": row[3].strftime("%Y-%m-%d") if row[3] else None
+            } for row in c.fetchall()]
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_task_detail_from_db(task_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                SELECT t.task_id, t.user_id, t.task_name, h.hive_number, t.description, 
+                       t.deadline_date, t.status
+                FROM Task t
+                LEFT JOIN Hive h ON t.hive_id = h.hive_id
+                WHERE t.task_id = %s
+            """, (task_id,))
+            row = c.fetchone()
+            if row:
+                return {
+                    "task_id": row[0],
+                    "task_name": row[2],
+                    "hive_number": row[3],
+                    "description": row[4],
+                    "deadline_date": row[5].strftime("%Y-%m-%d") if row[5] else None,
+                    "status": row[6]
+                }
+            return None
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def update_task_status_to_completed(task_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                UPDATE Task 
+                SET status = 'completed'
+                WHERE task_id = %s
+            """, (task_id,))
+            if c.rowcount > 0:
+                conn.commit()
+                return True
+            return False
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def delete_task_from_db(task_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("DELETE FROM Task WHERE task_id = %s", (task_id,))
+            if c.rowcount > 0:
+                conn.commit()
+                return True
+            return False
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_all_notifications(user_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                SELECT notification_id, text, created_at, read_status
+                FROM notifications
+                WHERE user_id = %s
+                ORDER BY read_status = 'unread' DESC, created_at DESC
+            """, (user_id,))
+            return [{
+                "notification_id": row[0],
+                "text": row[1],
+                "created_at": row[2].strftime("%Y-%m-%d %H:%M:%S"),
+                "read_status": row[3]
+            } for row in c.fetchall()]
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def add_notification(user_id, text):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                INSERT INTO notifications (user_id, text, read_status, created_at)
+                VALUES (%s, %s, %s, CURRENT_TIMESTAMP + INTERVAL '5 hours')
+                RETURNING notification_id
+            """, (user_id, text, 'unread'))
+            notification_id = c.fetchone()[0]
+            conn.commit()
+            return notification_id
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def mark_notification_as_read(notification_id):
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("""
+                UPDATE notifications
+                SET read_status = 'read'
+                WHERE notification_id = %s
+            """, (notification_id,))
+            conn.commit()
+    finally:
+        db_pool.putconn(conn)
+
+@retry_on_eof(max_attempts=2, delay=3)
+def get_user_cities():
+    conn = db_pool.getconn()
+    try:
+        with conn.cursor() as c:
+            c.execute("SELECT user_id, city FROM farm WHERE city IS NOT NULL AND city != ''")
+            return {row[0]: row[1] for row in c.fetchall()}
+    finally:
+        db_pool.putconn(conn)

forget.py

@@ -0,0 +1,104 @@
+import os
+import logging
+from flask import jsonify
+from sendgrid import SendGridAPIClient
+from sendgrid.helpers.mail import Mail
+from database import generate_reset_code, verify_reset_code, update_user_password
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Email configuration using environment variables
+EMAIL_ADDRESS = os.environ.get('EMAIL_ADDRESS')
+SENDGRID_API_KEY = os.environ.get('SENDGRID_API_KEY')
+SENDER_NAME = os.environ.get('SENDER_NAME', 'BeeGuardian Team')
+COMPANY_ADDRESS = os.environ.get('COMPANY_ADDRESS', 'Namal University')
+COMPANY_CITY = os.environ.get('COMPANY_CITY', 'Mianwali')
+COMPANY_STATE = os.environ.get('COMPANY_STATE', 'Punjab')
+COMPANY_ZIP = os.environ.get('COMPANY_ZIP', '42200')
+COMPANY_COUNTRY = os.environ.get('COMPANY_COUNTRY', 'Pakistan')
+
+# Send email with reset code using SendGrid
+def send_reset_email(email, code):
+    if not EMAIL_ADDRESS or not SENDGRID_API_KEY:
+        logger.error("Email configuration missing")
+        return False, "Email configuration missing"
+    
+    # Email content with BeeGuardian intro and CAN-SPAM compliant footer
+    footer = (
+        f"\n\n--\n"
+        f"{SENDER_NAME}\n"
+        f"{COMPANY_ADDRESS}\n"
+        f"{COMPANY_CITY}, {COMPANY_STATE} {COMPANY_ZIP}\n"
+        f"{COMPANY_COUNTRY}"
+    )
+    content = (
+        f"Welcome to BeeGuardian! We are a team of students from Namal University Mianwali who created an innovative app to help beekeepers monitor bee health using mobile phone recordings. Our mission is to protect bees and support biodiversity.\n\n"
+        f"To reset your password, please use this code: {code}\n"
+        f"This code is valid for 15 minutes.{footer}"
+    )
+    
+    message = Mail(
+        from_email=(EMAIL_ADDRESS, SENDER_NAME),
+        to_emails=email,
+        subject='Password Reset Code for BeeGuardian',
+        plain_text_content=content
+    )
+    try:
+        sg = SendGridAPIClient(SENDGRID_API_KEY)
+        response = sg.send(message)
+        return True, None
+    except Exception as e:
+        logger.error(f"Failed to send email to {email}: {str(e)}")
+        return False, str(e)
+
+# Forgot password logic
+def forgot_password(request):
+    data = request.json
+    if 'email' not in data:
+        logger.warning("Forgot password request missing email")
+        return jsonify({"error": "Email is required"}), 400
+    try:
+        code = generate_reset_code(data['email'])
+        if not code:
+            return jsonify({"error": "Email not found"}), 404
+        success, error_msg = send_reset_email(data['email'], code)
+        if success:
+            return jsonify({"success": True, "message": "Reset code sent to email"}), 200
+        logger.error(f"Failed to send reset email: {error_msg}")
+        return jsonify({"error": f"Failed to send email: {error_msg}"}), 500
+    except Exception as e:
+        logger.error(f"Error in forgot_password for {data['email']}: {str(e)}")
+        return jsonify({"error": str(e)}), 500
+
+# Verify reset code logic
+def verify_reset_code_endpoint(request):
+    data = request.json
+    if not all(key in data for key in ['email', 'code']):
+        logger.warning("Verify reset code request missing email or code")
+        return jsonify({"error": "Email and code are required"}), 400
+    try:
+        valid = verify_reset_code(data['email'], data['code'])
+        if valid:
+            return jsonify({"success": True, "message": "Code verified"}), 200
+        return jsonify({"error": "Invalid or expired code"}), 400
+    except Exception as e:
+        logger.error(f"Error in verify_reset_code for {data['email']}: {str(e)}")
+        return jsonify({"error": str(e)}), 500
+
+# Reset password logic
+def reset_password(request):
+    data = request.json
+    if not all(key in data for key in ['email', 'new_password']):
+        logger.warning("Reset password request missing required fields")
+        return jsonify({"error": "Email and new password are required"}), 400
+    try:
+        updated = update_user_password(data['email'], data['new_password'])
+        if updated:
+            return jsonify({"success": True, "message": "Password reset successfully"}), 200
+        logger.error(f"Failed to update password for {data['email']}")
+        return jsonify({"error": "Failed to update password"}), 500
+    except Exception as e:
+        logger.error(f"Error in reset_password for {data['email']}: {str(e)}")
+        return jsonify({"error": str(e)}), 500