Update main.py

main.py

@@ -5,7 +5,7 @@ import uuid
 import re
 import json
 import traceback
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 from flask import Flask, request, jsonify
 from flask_cors import CORS
@@ -68,6 +68,56 @@ def is_valid_email(email):
     regex = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
     return re.match(regex, email) is not None
 
+def _send_notification(user_id, user_email, message_content, send_email=False, email_subject=None, email_body=None):
+    """
+    Internal helper to send notifications.
+    Creates an in-app notification in Firebase and optionally sends an email via Resend.
+    If user_id is None, it will only attempt to send an email.
+    """
+    timestamp = datetime.now(timezone.utc).isoformat()
+    
+    # 1. Send In-App Notification (if user_id is provided)
+    if user_id:
+        try:
+            notif_ref = db.reference(f'notifications/{user_id}').push()
+            notif_data = {
+                'id': notif_ref.key,
+                'message': message_content,
+                'created_at': timestamp,
+                'read': False,
+                'read_at': None
+            }
+            notif_ref.set(notif_data)
+            logger.info(f"Successfully sent in-app notification to UID {user_id}")
+        except Exception as e:
+            logger.error(f"Failed to send in-app notification to UID {user_id}: {e}")
+            return False # Fail the whole operation if in-app fails for a registered user
+
+    # 2. Send Email via Resend (if requested)
+    if send_email and user_email:
+        if not RESEND_API_KEY:
+            logger.error("RESEND_API_KEY is not configured. Cannot send email.")
+            return False
+        
+        headers = {
+            "Authorization": f"Bearer {RESEND_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "from": "Sozo <onboarding@sozofix.tech>", # Replace with your verified Resend domain
+            "to": [user_email],
+            "subject": email_subject,
+            "html": email_body
+        }
+        try:
+            response = requests.post("https://api.resend.com/emails", json=payload)
+            response.raise_for_status()
+            logger.info(f"Successfully sent email to {user_email}")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Failed to send email to {user_email} via Resend: {e}")
+            return False
+            
+    return True
 # -----------------------------------------------------------------------------
 # 3. AUTHENTICATION & USER MANAGEMENT
 # -----------------------------------------------------------------------------
@@ -901,6 +951,103 @@ def get_feedback_details(feedback_id):
         traceback.print_exc()
         return jsonify({'error': str(e)}), 500
 # -----------------------------------------------------------------------------
+# 4. NOTIFICATION ENDPOINTS
+# -----------------------------------------------------------------------------
+
+@app.route('/api/admin/notifications/send', methods=['POST'])
+def admin_send_notification():
+    logger.info("Endpoint /api/admin/notifications/send POST: Received request.")
+    try:
+        verify_admin(request.headers.get('Authorization'))
+        
+        data = request.get_json()
+        message_content = data.get('message')
+        target_group = data.get('target_group', 'all')
+        target_users_list = data.get('target_users', [])
+        
+        send_as_email = data.get('send_as_email', False)
+        email_subject = data.get('email_subject')
+        email_body_html = data.get('email_body_html')
+
+        if not message_content:
+            return jsonify({'error': 'In-app notification message is required'}), 400
+        if send_as_email and (not email_subject or not email_body_html):
+            return jsonify({'error': 'Email subject and body are required when sending as email.'}), 400
+
+        recipients = [] # List of tuples (uid, email)
+        
+        if target_group == 'all':
+            all_users = db.reference('users').get() or {}
+            for uid, user_data in all_users.items():
+                recipients.append((uid, user_data.get('email')))
+        elif target_group == 'waitlist':
+            waitlist_users = db.reference('sozo_waitlist').get() or {}
+            for _, user_data in waitlist_users.items():
+                # For waitlist, UID is None as they are not registered users yet
+                recipients.append((None, user_data.get('email')))
+        elif target_users_list:
+            all_users = db.reference('users').get() or {}
+            for uid in target_users_list:
+                if uid in all_users:
+                    recipients.append((uid, all_users[uid].get('email')))
+        else:
+            return jsonify({'error': 'Invalid target specified'}), 400
+        
+        sent_count = 0
+        for uid_recipient, email_recipient in recipients:
+            if _send_notification(
+                user_id=uid_recipient,
+                user_email=email_recipient,
+                message_content=message_content,
+                send_email=send_as_email,
+                email_subject=email_subject,
+                email_body=email_body_html
+            ):
+                sent_count += 1
+                
+        return jsonify({'success': True, 'message': f"Notification dispatched for {sent_count} recipient(s)."}), 200
+        
+    except PermissionError as e:
+        return jsonify({'error': str(e)}), 403
+    except Exception as e:
+        logger.error(f"CRITICAL ERROR during notification send: {traceback.format_exc()}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/user/notifications', methods=['GET'])
+def get_user_notifications():
+    try:
+        token = request.headers.get('Authorization', '').split(' ')[1]
+        uid = verify_token(token)
+        if not uid: return jsonify({'error': 'Unauthorized'}), 401
+
+        notifications_ref = db.reference(f'notifications/{uid}')
+        user_notifications = notifications_ref.order_by_child('created_at').get() or {}
+        
+        # Sort descending (newest first)
+        sorted_notifications = sorted(user_notifications.values(), key=lambda item: item['created_at'], reverse=True)
+        
+        return jsonify(sorted_notifications), 200
+    except Exception as e:
+        logger.error(f"CRITICAL ERROR getting notifications: {traceback.format_exc()}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/user/notifications/<string:notification_id>/read', methods=['POST'])
+def mark_notification_read(notification_id):
+    try:
+        token = request.headers.get('Authorization', '').split(' ')[1]
+        uid = verify_token(token)
+        if not uid: return jsonify({'error': 'Unauthorized'}), 401
+
+        notif_ref = db.reference(f'notifications/{uid}/{notification_id}')
+        if not notif_ref.get():
+            return jsonify({'error': 'Notification not found'}), 404
+            
+        notif_ref.update({'read': True, 'read_at': datetime.now(timezone.utc).isoformat()})
+        return jsonify({'success': True, 'message': 'Notification marked as read.'}), 200
+    except Exception as e:
+        logger.error(f"CRITICAL ERROR marking notification read: {traceback.format_exc()}")
+        return jsonify({'error': str(e)}), 500
+# -----------------------------------------------------------------------------
 # 7. MAIN EXECUTION
 # -----------------------------------------------------------------------------
 if __name__ == '__main__':