diff --git "a/main.py" "b/main.py" --- "a/main.py" +++ "b/main.py" @@ -1,730 +1,1595 @@ -import os -import io -import json -import hashlib -from datetime import datetime, time, timedelta -from PIL import Image -import pytz -from flask import Flask, request, jsonify, send_file +# -*- coding: utf-8 -*- +from flask import Flask, request, jsonify, g as flask_g # flask_g for storing user context from flask_cors import CORS -import google.generativeai as genai +import json +import os +import graphviz +from datetime import datetime +import re +import uuid # For generating unique IDs +import random # For quiz options shuffling +import google.generativeai as genai # Gemini API +from collections import defaultdict # For timeline and sibling grouping import firebase_admin -from firebase_admin import credentials, db, storage, auth -import pandas as pd -import requests -from urllib.parse import urlparse, unquote -import numpy as np +from firebase_admin import credentials, db, auth as firebase_auth # Added firebase_auth +from copy import deepcopy # For comparing data states +from dictdiffer import diff # Using dictdiffer for easier comparison +from functools import wraps # For authentication decorator +# --- Flask Setup --- app = Flask(__name__) -CORS(app) - -# Firebase initialization -cred = credentials.Certificate('mydateproject-e7994-firebase-adminsdk-mpa9a-2fd9c32a98.json') -firebase_admin.initialize_app(cred, { - 'databaseURL': 'https://mydateproject-e7994.firebaseio.com', - 'storageBucket': 'mydateproject-e7994.firebasestorage.app' -}) - -bucket = storage.bucket() -api_key = os.environ['Gemini'] -FIREBASE_API_KEY = os.environ.get('FIREBASE_API_KEY') - - -# Helper functions -def configure_gemini(): - genai.configure(api_key=api_key) - return genai.GenerativeModel('gemini-2.0-flash-thinking-exp') - -def verify_token(token): - try: - decoded_token = auth.verify_id_token(token) - return decoded_token['uid'] - except Exception as e: - return None +CORS(app) # Enable CORS for all routes + +# --- Configuration & Constants --- +DEFAULT_PROFILE = { + "profile": {"name": "", "dob": "", "gender": "Unknown", "phone": ""}, + "family_members": [], + "relationships": [], + "settings": {"theme": "Default", "privacy": "Private"}, + "metadata": {"owner_phone": "", "tree_name": "My Family Tree", "created_at": ""} +} +DEFAULT_MEMBER_STRUCTURE = { + "id": "", "name": "", "dob": "", "dod": "", "gender": "Unknown", + "phone": "", "stories": [], "totem": "", + "created_at": "", "created_by": "", + "last_edited_at": "", "last_edited_by": "" +} +DEFAULT_STORY_STRUCTURE = { + "timestamp": "", "text": "", "added_by": "" +} +GEMINI_MODEL_NAME = "gemini-2.0-flash" + +# --- Environment Variable Loading --- +Firebase_DB_URL = os.environ.get("Firebase_DB") +Firebase_Credentials_JSON_Str = os.environ.get("FIREBASE") +GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY") + +# --- Firebase Initialization --- +firebase_app = None +firebase_db_ref = None +firebase_error = None + +try: + if Firebase_Credentials_JSON_Str and Firebase_DB_URL: + credentials_json_parsed = json.loads(Firebase_Credentials_JSON_Str) + if not firebase_admin._apps: + cred = credentials.Certificate(credentials_json_parsed) + firebase_app = firebase_admin.initialize_app(cred, {'databaseURL': Firebase_DB_URL}) + firebase_db_ref = db.reference('/') + app.logger.info("Firebase Admin SDK initialized successfully.") + else: + firebase_app = firebase_admin.get_app() + firebase_db_ref = db.reference('/') + app.logger.info("Firebase Admin SDK already initialized.") + else: + firebase_error = "Firebase secrets (Firebase_DB, FIREBASE) missing in environment variables." + app.logger.error(firebase_error) +except Exception as e: + firebase_error = f"Error initializing Firebase: {e}" + app.logger.error(firebase_error) + +# --- Gemini API Client Initialization --- +genai_client = None +api_key_error = False +try: + if not GOOGLE_API_KEY: + api_key_error = True + app.logger.error("GOOGLE_API_KEY missing in environment variables.") + else: + genai.configure(api_key=GOOGLE_API_KEY) + genai_client = genai + app.logger.info("Gemini API Client initialized successfully.") +except Exception as e: + api_key_error = True + app.logger.error(f"Error initializing Gemini API Client: {e}") + +# --- Authentication Decorator --- +def token_required(f): + @wraps(f) + def decorated_function(*args, **kwargs): + if firebase_error: # Check if Firebase Admin SDK initialized properly + return jsonify({"error": "Authentication service not available", "detail": "Firebase Admin SDK not initialized."}), 503 -def check_daily_reset(user_ref): - try: - user_data = user_ref.get() - now = datetime.now(pytz.UTC) - last_reset = datetime.fromisoformat(user_data.get('last_reset', '2000-01-01T00:00:00+00:00')) + auth_header = request.headers.get('Authorization') + if not auth_header or not auth_header.startswith('Bearer '): + return jsonify({"error": "Authorization token is missing or invalid"}), 401 - if now.time() >= time(8,0) and last_reset.date() < now.date(): - user_ref.update({ - 'remaining_cash': user_data['daily_cash'], - 'last_reset': now.isoformat() - }) - return True - return False - except Exception as e: - print(f"Reset error: {str(e)}") - return False + id_token = auth_header.split('Bearer ')[1] + try: + decoded_token = firebase_auth.verify_id_token(id_token) + flask_g.user = { + "uid": decoded_token.get('uid'), + "phone_number": decoded_token.get('phone_number') # This is crucial + } + if not flask_g.user["phone_number"]: + app.logger.error(f"Token for UID {flask_g.user['uid']} does not contain a phone number.") + return jsonify({"error": "Authenticated user has no phone number associated."}), 403 + + # Normalize the phone number from the token immediately + flask_g.user["phone_number"] = normalize_phone(flask_g.user["phone_number"]) + if not flask_g.user["phone_number"]: + app.logger.error(f"Failed to normalize phone number from token for UID {flask_g.user['uid']}.") + return jsonify({"error": "Invalid phone number format in token."}), 403 + + except firebase_auth.ExpiredIdTokenError: + return jsonify({"error": "Token has expired"}), 401 + except firebase_auth.InvalidIdTokenError: + return jsonify({"error": "Token is invalid"}), 401 + except Exception as e: + app.logger.error(f"Error during token verification: {e}") + return jsonify({"error": "Could not verify token", "detail": str(e)}), 500 -# Process receipt image -def process_receipt(model, image): - prompt = """Analyze this image and determine if it's a receipt. If it is a receipt, extract: - - Total amount (as float) - - List of items purchased (array of strings) - - Date of transaction (DD/MM/YYYY format) - - Receipt number (as string) - Return JSON format with keys: is_receipt (boolean), total, items, date, receipt_number. - If not a receipt, return {"is_receipt": false}""" + return f(*args, **kwargs) + return decorated_function + + +# --- Helper Functions (Adapted for API context) --- +def normalize_phone(phone): + if not phone: return None + phone_str = str(phone).strip() + if not re.match(r"^\+\d{5,}$", phone_str): # Basic E.164-like check + # Allow numbers that might come from Firebase Auth without '+' if they are otherwise valid + if re.match(r"^\d{10,}$", phone_str.replace("+", "")): # If it's digits only and long enough + digits_only = "".join(filter(str.isdigit, phone_str)) + return f"+{digits_only}" # Attempt to normalize by adding '+' + return None + digits = "".join(filter(str.isdigit, phone_str)) + return f"+{digits}" + +def get_user_db_path(owner_phone): + normalized = normalize_phone(owner_phone) + if not normalized: return None + return f'users/{normalized}' + +def get_phone_index_path(member_phone): + normalized = normalize_phone(member_phone) + if not normalized: return None + return f'phone_index/{normalized}' + +def get_pending_changes_path(owner_phone, proposer_phone=None): + norm_owner = normalize_phone(owner_phone) + if not norm_owner: return None + base_path = f'pending_changes/{norm_owner}' + if proposer_phone: + norm_proposer = normalize_phone(proposer_phone) + if not norm_proposer: return None + return f'{base_path}/{norm_proposer}' + return base_path + +# --- Data Loading (Adapted) --- +def load_tree_data(owner_phone_to_load): # Renamed param to avoid conflict with flask_g.user.phone_number + if firebase_error or not firebase_db_ref: + return None, firebase_error or "Firebase not initialized" + norm_owner_phone_to_load = normalize_phone(owner_phone_to_load) + if not norm_owner_phone_to_load: + return None, "Invalid owner phone format for loading data." + + user_path = get_user_db_path(norm_owner_phone_to_load) + if not user_path: + return None, "Invalid owner phone format for loading data (path generation failed)." try: - response = model.generate_content([prompt, image]) - return response.text + data = firebase_db_ref.child(user_path).get() + if data and isinstance(data, dict): + merged_data = deepcopy(DEFAULT_PROFILE) + if "metadata" not in data or not isinstance(data["metadata"], dict): data["metadata"] = {} + merged_data.update(data) + merged_data["settings"] = {**DEFAULT_PROFILE["settings"], **data.get("settings", {})} + merged_data["metadata"] = {**DEFAULT_PROFILE["metadata"], **data.get("metadata", {})} + merged_data["metadata"]["owner_phone"] = norm_owner_phone_to_load + + updated_members = [] + for member_data in merged_data.get("family_members", []): + if isinstance(member_data, dict): + complete_member = deepcopy(DEFAULT_MEMBER_STRUCTURE) + member_data.pop('photo_path', None) + complete_member.update(member_data) + updated_members.append(complete_member) + merged_data["family_members"] = updated_members + + if not isinstance(merged_data.get("relationships"), list): merged_data["relationships"] = [] + + for member in merged_data["family_members"]: + if "stories" not in member or not isinstance(member["stories"], list): member["stories"] = [] + cleaned_stories = [] + for story in member.get("stories", []): + if isinstance(story, dict): + complete_story = deepcopy(DEFAULT_STORY_STRUCTURE) + complete_story.update(story) + cleaned_stories.append(complete_story) + member["stories"] = cleaned_stories + return merged_data, None + elif data is None: # New tree + app.logger.info(f"No existing tree data for {norm_owner_phone_to_load}. Initializing new tree.") + new_tree = deepcopy(DEFAULT_PROFILE) + new_tree["metadata"]["owner_phone"] = norm_owner_phone_to_load + new_tree["metadata"]["created_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + + # The 'Me' node represents the owner of this tree. + # Its phone number is the owner's phone number. + owner_me_node = deepcopy(DEFAULT_MEMBER_STRUCTURE) + owner_me_node.update({ + "id": "Me", "name": "Me", # User can update name later via profile + "phone": norm_owner_phone_to_load, # This is key + "created_at": new_tree["metadata"]["created_at"], + "created_by": norm_owner_phone_to_load # Owner created their own 'Me' node + }) + new_tree["family_members"].append(owner_me_node) + new_tree["profile"]["phone"] = norm_owner_phone_to_load # Profile phone also set + + # Save this new tree structure immediately + initial_save_success, initial_save_error = save_tree_data(norm_owner_phone_to_load, new_tree, DEFAULT_PROFILE) # Pass owner's phone + if not initial_save_success: + app.logger.error(f"Failed to save initial tree for {norm_owner_phone_to_load}: {initial_save_error}") + return None, f"Failed to initialize and save new tree: {initial_save_error}" + app.logger.info(f"Successfully initialized and saved new tree for {norm_owner_phone_to_load}.") + return new_tree, None + else: + return None, f"Invalid data format found for tree owner {norm_owner_phone_to_load}." except Exception as e: - print(f"Gemini error: {str(e)}") - return "{}" - + app.logger.error(f"Error loading tree data for {norm_owner_phone_to_load}: {e}") + return None, f"Error loading tree data: {e}" -# Write report -@app.route('/api/write-report', methods=['POST']) -def generate_report(): - prompt = """You are the TrueSpend AI analyst, analyze this transaction data - and write an insightful business report on the spending habits of the employees. - Make sure the report is in plain text""" - model = configure_gemini() +def find_linked_trees(member_phone): + if firebase_error or not firebase_db_ref: return {}, firebase_error or "Firebase not initialized" + index_path = get_phone_index_path(member_phone) + if not index_path: return {}, "Invalid member phone for index query." try: - transaction_data = request.get_json() - transaction_json_string = json.dumps(transaction_data['transactions']) - response = model.generate_content([prompt, transaction_json_string]) - report = response.text - return jsonify({"report": report}) + owner_phones_dict = firebase_db_ref.child(index_path).child("trees").get() + return owner_phones_dict if owner_phones_dict and isinstance(owner_phones_dict, dict) else {}, None except Exception as e: - return jsonify({"error": str(e)}), 500 - -# ======================================== -# Authentication Endpoints -# ======================================== -# (Any existing authentication endpoints remain unchanged) - -# ======================================== -# Image Receipt Processing Endpoint -# ======================================== -@app.route('/api/process-receipt', methods=['POST']) -def process_receipt_endpoint(): + app.logger.error(f"Error querying phone index for {member_phone}: {e}") + return {}, f"Error querying phone index: {e}" + +# --- Index Update Logic (Adapted) --- +def update_phone_index(owner_phone_of_tree, previous_members, current_members): # Renamed param + if firebase_error or not firebase_db_ref: + return False, firebase_error or "Firebase not initialized" + + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return False, "Invalid owner phone for index update." + + prev_phones = {normalize_phone(p.get('phone')) for p in previous_members if isinstance(p, dict) and normalize_phone(p.get('phone'))} + curr_phones = {normalize_phone(p.get('phone')) for p in current_members if isinstance(p, dict) and normalize_phone(p.get('phone'))} + + phones_added = curr_phones - prev_phones + phones_removed = prev_phones - curr_phones + + updates = {} + for phone in phones_added: + if phone: + index_entry_path = f"{get_phone_index_path(phone)}/trees/{norm_owner_phone_of_tree}" + updates[index_entry_path] = True + for phone in phones_removed: + if phone: + index_entry_path = f"{get_phone_index_path(phone)}/trees/{norm_owner_phone_of_tree}" + updates[index_entry_path] = None + + if not updates: return True, None try: - auth_header = request.headers.get('Authorization') - token = auth_header.split('Bearer ')[1] if auth_header else None - uid = verify_token(token) if token else None - - if not uid: - return jsonify({'error': 'Invalid token'}), 401 - - user_ref = db.reference(f'users/{uid}') - user_data = user_ref.get() - - # If the confirmation flag is set, then use the form fields (and hidden file_hash/image_url) - # to create the transaction. (Note: image_bytes is None because the image was already uploaded.) - if request.form.get('confirmed') == 'true': - data = { - 'total': float(request.form.get('total')), - 'items': [item.strip() for item in request.form.get('items', '').split(',')], - 'date': request.form.get('date'), - 'receipt_number': request.form.get('receipt_number'), - 'is_receipt': True, - 'image_url': request.form.get('image_url') # provided by the first submission - } - file_hash = request.form.get('file_hash', '') - # In this confirmation branch, we pass image_bytes as None. - return validate_and_save_transaction( - uid=uid, - user_data=user_data, - data=data, - file_hash=file_hash, - image_bytes=None, - manual=False - ) - - # Handle image processing (first submission) - file = request.files.get('receipt') - if not file: - return jsonify({'error': 'No file uploaded'}), 400 - - image_bytes = file.read() - file_hash = hashlib.md5(image_bytes).hexdigest() - - transactions_ref = db.reference('transactions') - existing = transactions_ref.order_by_child('hash').equal_to(file_hash).get() - if existing: - return jsonify({'error': 'Receipt already processed'}), 400 - - # Immediately upload the image so that it is stored regardless of review outcome. - timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') - blob = bucket.blob(f'receipts/{uid}/{timestamp}_{file_hash}.jpg') - blob.upload_from_string(image_bytes, content_type='image/jpeg') - image_url = blob.public_url - - # Process the image with Gemini - image = Image.open(io.BytesIO(image_bytes)) - # --- Image Compression --- - compressed_buffer = io.BytesIO() - image.save(compressed_buffer, format="JPEG", optimize=True, quality=90) # Adjust quality as needed - compressed_image_bytes = compressed_buffer.getvalue() - compressed_image = Image.open(io.BytesIO(compressed_image_bytes)) - model = configure_gemini() - result_text = process_receipt(model, compressed_image) - - try: - json_str = result_text[result_text.find('{'):result_text.rfind('}')+1] - data = json.loads(json_str) - except json.JSONDecodeError: - return jsonify({'error': 'Failed to parse receipt data', 'raw_response': result_text}), 400 + firebase_db_ref.update(updates) + return True, None + except Exception as e: + app.logger.error(f"Error updating phone index: {e}. Updates: {json.dumps(updates)}") + return False, f"Error updating phone index: {e}" - if not data.get('is_receipt', False): - return jsonify({'error': 'Not a valid receipt'}), 400 +# --- Data Saving (Owner - Adapted) --- +def save_tree_data(owner_phone_of_tree, current_data, previous_data): # Renamed param + if firebase_error or not firebase_db_ref: + return False, firebase_error or "Firebase not initialized. Cannot save." + + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: + return False, "Invalid owner phone format for saving." - # Instead of saving immediately, return the extracted data along with the image info for review. - data['file_hash'] = file_hash - data['image_url'] = image_url - return jsonify({ - 'success': True, - 'extracted': True, - 'data': data, - 'message': 'Review extracted information before confirming.' - }) + user_path = get_user_db_path(norm_owner_phone_of_tree) + if not user_path: # Should not happen if norm_owner_phone_of_tree is valid + return False, "Failed to generate user DB path for saving." - except Exception as e: - print(e) - return jsonify({'error': str(e)}), 500 + update_totems(current_data) + current_data["metadata"]["owner_phone"] = norm_owner_phone_of_tree # Ensure this is set correctly + if "family_members" in current_data: + for member in current_data["family_members"]: + if isinstance(member, dict): member.pop('photo_path', None) -# ======================================== -# Manual Entry Endpoint -# ======================================== -@app.route('/api/manual-entry', methods=['POST']) -def manual_entry_endpoint(): try: - auth_header = request.headers.get('Authorization') - token = auth_header.split('Bearer ')[1] if auth_header else None - uid = verify_token(token) if token else None + firebase_db_ref.child(user_path).set(current_data) + except Exception as e: + app.logger.error(f"Error saving tree data to {user_path}: {e}") + return False, f"Error saving tree data: {e}" + + prev_members = previous_data.get("family_members", []) if previous_data and isinstance(previous_data, dict) else [] + curr_members = current_data.get("family_members", []) + index_success, index_error = update_phone_index(norm_owner_phone_of_tree, prev_members, curr_members) + if not index_success: + app.logger.warning(f"Tree data saved for {norm_owner_phone_of_tree}, but failed to update phone index: {index_error}") + return True, f"Tree data saved, but phone index update failed: {index_error}" # Data saved, but index failed + return True, None + +# --- Collaboration Functions (Adapted) --- +# Proposer phone is the authenticated user (flask_g.user.phone_number) +def propose_changes(owner_phone_of_tree, proposer_phone_from_token, proposed_data): + if firebase_error or not firebase_db_ref: + return False, firebase_error or "Firebase not initialized. Cannot propose." + + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + norm_proposer_phone = normalize_phone(proposer_phone_from_token) - if not uid: - return jsonify({'error': 'Invalid token'}), 401 + if not norm_owner_phone_of_tree or not norm_proposer_phone: + return False, "Invalid owner or proposer phone format for proposing changes." - user_ref = db.reference(f'users/{uid}') - user_data = user_ref.get() + pending_path = get_pending_changes_path(norm_owner_phone_of_tree, norm_proposer_phone) + if not pending_path: # Should not happen if phones are valid + return False, "Failed to generate pending changes path." - return handle_manual_entry(uid, user_ref, user_data) + proposal_payload = { + "proposed_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "proposer_phone": norm_proposer_phone, # Storing the proposer's phone + "tree_data": proposed_data + } + try: + firebase_db_ref.child(pending_path).set(proposal_payload) + return True, None except Exception as e: - return jsonify({'error': str(e)}), 500 + app.logger.error(f"Error proposing changes to {pending_path}: {e}") + return False, f"Error proposing changes: {e}" +# Owner phone is the authenticated user (flask_g.user.phone_number) +def load_pending_changes(owner_phone_from_token): + if firebase_error or not firebase_db_ref: return {}, firebase_error or "Firebase not initialized" + + norm_owner_phone = normalize_phone(owner_phone_from_token) + if not norm_owner_phone: return {}, "Invalid owner phone for loading pending changes." -def handle_manual_entry(uid, user_ref, user_data): + pending_base_path = get_pending_changes_path(norm_owner_phone) + if not pending_base_path: return {}, "Failed to generate pending base path." try: - data = { - 'total': float(request.form.get('total')), - 'items': [item.strip() for item in request.form.get('items', '').split(',')], - 'date': request.form.get('date'), - 'receipt_number': request.form.get('receipt_number'), - 'is_receipt': True - } - - return validate_and_save_transaction( - uid=uid, - user_data=user_data, - data=data, - file_hash=hashlib.md5(str(datetime.now()).encode()).hexdigest(), - image_bytes=None, - manual=True - ) + data = firebase_db_ref.child(pending_base_path).get() + return data if data and isinstance(data, dict) else {}, None except Exception as e: - return jsonify({'error': str(e)}), 400 - - -def validate_and_save_transaction(uid, user_data, data, file_hash, image_bytes, manual=False): - transactions_ref = db.reference('transactions') - receipt_number = data.get('receipt_number') - items = data.get('items', []) - - # Check for duplicate transactions based on receipt number and items - existing_transactions_with_receipt = transactions_ref.order_by_child('receipt_number').equal_to(receipt_number).get() - - if existing_transactions_with_receipt: - for transaction_id, existing_transaction_data in existing_transactions_with_receipt.items(): - existing_items = sorted(existing_transaction_data.get('items', [])) - current_items = sorted(items) - if existing_items == current_items: - return jsonify({'error': f"Transaction with Receipt #{receipt_number} and identical items already exists"}), 400 - - total = float(data.get('total', 0)) - - # Initialize image_url from data (could be None) - image_url = data.get('image_url') - - # Upload image if image_bytes are provided and not manual - if image_bytes and not manual: - timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') - blob = bucket.blob(f'receipts/{uid}/{timestamp}_{file_hash}.jpg') - blob.upload_from_string(image_bytes, content_type='image/jpeg') - image_url = blob.public_url - - # Update user cash - allowing negative values - new_remaining = user_data['remaining_cash'] - total - db.reference(f'users/{uid}').update({'remaining_cash': new_remaining}) - - # Build transaction data without image_url initially - transaction_data = { - 'uid': uid, - 'total': total, - 'items': items, - 'date': data.get('date'), - 'receipt_number': receipt_number, - 'timestamp': datetime.now(pytz.UTC).isoformat(), - 'hash': file_hash, - 'manual_entry': manual - } + app.logger.error(f"Error loading pending changes for {norm_owner_phone}: {e}") + return {}, f"Error loading pending changes: {e}" - # Only add image_url if it is not None - if image_url is not None: - transaction_data['image_url'] = image_url +# Owner phone is the authenticated user (flask_g.user.phone_number) +def accept_changes(owner_phone_from_token, proposer_phone_to_accept): + if firebase_error or not firebase_db_ref: return False, firebase_error or "Firebase not initialized" - # Save the transaction - new_transaction_ref = transactions_ref.push(transaction_data) - return jsonify({ - 'success': True, - 'transaction': {**transaction_data, 'id': new_transaction_ref.key}, - 'remaining_cash': new_remaining - }) + norm_owner_phone = normalize_phone(owner_phone_from_token) + norm_proposer_phone = normalize_phone(proposer_phone_to_accept) + + if not norm_owner_phone or not norm_proposer_phone: + return False, "Invalid owner or proposer phone for accepting changes." -# ======================================== -# Data Endpoints for Visualizations -# ======================================== + pending_path = get_pending_changes_path(norm_owner_phone, norm_proposer_phone) + if not pending_path: return False, "Failed to generate pending path for accept." -@app.route('/api/user/spending-overview', methods=['GET']) -def get_spending_overview(): try: - # Extract the token and verify it. - auth_header = request.headers.get('Authorization', '') - token = auth_header.split(' ')[1] if len(auth_header.split(' ')) > 1 else '' - uid = verify_token(token) - - # Get transactions for the user. - transactions_ref = db.reference('transactions') - transactions = transactions_ref.order_by_child('uid').equal_to(uid).get() or {} - - # Convert to list for easier processing - transactions_list = [] - for tx_id, tx_data in transactions.items(): - # Add ID to the transaction data - tx_item = tx_data.copy() - tx_item['id'] = tx_id - transactions_list.append(tx_item) - - # Create a DataFrame - df = pd.DataFrame(transactions_list) if transactions_list else pd.DataFrame() - - if df.empty: - return jsonify({ - 'daily_spending': [], - 'recent_transactions': [] - }) - - # Handle date parsing without dropping invalid dates - if 'date' in df.columns: - # Create a temporary column for parsed dates - df['parsed_date'] = pd.to_datetime(df['date'], errors='coerce') - - # For rows with invalid dates, set a default date - default_date = pd.Timestamp('2000-01-01') - mask = df['parsed_date'].isna() - - if mask.any(): - print(f"Found {mask.sum()} transactions with invalid dates") - # Keep the original string in 'date' column, but use default for calculations - df.loc[mask, 'parsed_date'] = default_date - - # Create ISO format dates for valid dates - df['date_iso'] = df['parsed_date'].apply(lambda d: d.isoformat() if pd.notnull(d) else '2000-01-01T00:00:00') - - # Extract date part for daily spending calculations - df['date_only'] = df['date_iso'].apply(lambda d: d.split('T')[0]) - else: - # If no date column exists, create default values - df['date_only'] = '2000-01-01' - df['date_iso'] = '2000-01-01T00:00:00' - - # For daily spending, group by date - daily_spending = df.groupby('date_only')['total'].sum().reset_index() - daily_spending.rename(columns={'date_only': 'date'}, inplace=True) - - # Sort transactions by timestamp if available - if 'timestamp' in df.columns: - df = df.sort_values(by='timestamp', ascending=False) - - # Select the most recent transactions - recent_transactions = df.head(10) - - # Replace NaN with None for JSON serialization - daily_spending = daily_spending.replace({np.nan: None}) - recent_transactions = recent_transactions.replace({np.nan: None}) - - # Ensure proper column selections for the response - recent_tx_dict = recent_transactions.to_dict(orient='records') - - # Make sure each transaction has the original date string - for tx in recent_tx_dict: - # Remove temporary columns - if 'parsed_date' in tx: - del tx['parsed_date'] - if 'date_only' in tx: - del tx['date_only'] - if 'date_iso' in tx and 'date' not in tx: - tx['date'] = tx['date_iso'] - del tx['date_iso'] - elif 'date_iso' in tx: - del tx['date_iso'] - - return jsonify({ - 'daily_spending': daily_spending.to_dict(orient='records'), - 'recent_transactions': recent_tx_dict - }) + proposal_payload = firebase_db_ref.child(pending_path).get() + if not proposal_payload or "tree_data" not in proposal_payload: + return False, f"Proposal from {norm_proposer_phone} not found or invalid." + accepted_data = proposal_payload["tree_data"] + + previous_data, load_err = load_tree_data(norm_owner_phone) # Load owner's current tree + if load_err: + return False, f"Failed to load current owner data before accepting: {load_err}" + + save_success, save_error = save_tree_data(norm_owner_phone, accepted_data, previous_data) + if save_success: + firebase_db_ref.child(pending_path).delete() + return True, None + else: # save_error contains the reason + return False, f"Failed to save accepted changes or update index: {save_error}. Proposal not deleted." except Exception as e: - print(f"Error in spending overview: {e}") - return jsonify({'error': str(e)}), 500 - + app.logger.error(f"Error accepting changes from {norm_proposer_phone}: {e}") + return False, f"Error accepting changes: {e}" -# ======================================== -# Modified verify_admin function (now checks database is_admin flag) -# ======================================== -def verify_admin(auth_header): - if not auth_header or not auth_header.startswith('Bearer '): - raise ValueError('Invalid token') - - token = auth_header.split(' ')[1] - uid = verify_token(token) - if not uid: - raise PermissionError('Invalid user') +# Owner phone is the authenticated user (flask_g.user.phone_number) +def reject_changes(owner_phone_from_token, proposer_phone_to_reject): + if firebase_error or not firebase_db_ref: return False, firebase_error or "Firebase not initialized" + + norm_owner_phone = normalize_phone(owner_phone_from_token) + norm_proposer_phone = normalize_phone(proposer_phone_to_reject) - user_ref = db.reference(f'users/{uid}') - user_data = user_ref.get() - if not user_data or not user_data.get('is_admin', False): - raise PermissionError('Admin access required') + if not norm_owner_phone or not norm_proposer_phone: + return False, "Invalid owner or proposer phone for rejecting." + pending_path = get_pending_changes_path(norm_owner_phone, norm_proposer_phone) + if not pending_path: return False, "Failed to generate pending path for reject." try: - auth.set_custom_user_claims(uid, {"admin": True}) - print(f"Custom admin claim set for user {uid}") + firebase_db_ref.child(pending_path).delete() + return True, None except Exception as e: - print(f"Error setting custom admin claim: {e}") - raise PermissionError('Error setting admin claim, but admin verified') + app.logger.error(f"Error rejecting changes from {norm_proposer_phone}: {e}") + return False, f"Error rejecting changes: {e}" + +# (generate_diff_summary, find_person_by_id, find_person_by_name, generate_unique_id remain the same) +# (Graphviz and AI functions like format_node_label, get_father_id, update_totems, generate_graphviz_object, safe_json_loads, call_gemini, etc. remain largely the same logic) +# --- find_person_by_id, find_person_by_name, generate_unique_id --- +def find_person_by_id(data, person_id): + for person in data.get("family_members", []): + if isinstance(person, dict) and person.get("id") == person_id: return person + return None - return uid +def find_person_by_name(data, name): + if not name: return None + normalized_name = name.strip().lower() + return [ + person for person in data.get("family_members", []) + if isinstance(person, dict) and person.get("name", "").strip().lower() == normalized_name + ] + +def generate_unique_id(data=None): return uuid.uuid4().hex + + +# --- Graphviz, AI Functions (Adapted for API context) --- +def format_node_label(person): + label = f"{person.get('name', 'Unknown')}" + details = [] + if person.get('dob'): details.append(f"b. {person.get('dob')}") + if person.get('dod'): details.append(f"d. {person.get('dod')}") + if details: label += f"\n({' / '.join(details)})" + if person.get('totem'): label += f"\nTotem: {person.get('totem')}" + return label + +def get_father_id(person_id, relationships, members): + id_to_person = {p['id']: p for p in members if isinstance(p, dict)} + for rel in relationships: + if isinstance(rel, dict) and rel.get('type') == 'parent' and rel.get('to_id') == person_id: + parent_id = rel.get('from_id') + parent = id_to_person.get(parent_id) + if parent and parent.get('gender', '').lower() == 'male': + return parent_id + return None -# ======================================== -# Existing Admin Endpoints -# ======================================== -@app.route('/api/admin/overview', methods=['GET']) -def get_admin_overview(): +def update_totems(user_data): # Modifies user_data in-place + members = user_data.get("family_members", []) + relationships = user_data.get("relationships", []) + if not members or not relationships: return + id_to_person = {p['id']: p for p in members if isinstance(p, dict)} + visited = set(); processed_in_queue = set() + all_child_ids = {r['to_id'] for r in relationships if isinstance(r, dict) and r.get('type') == 'parent'} + queue = [p['id'] for p in members if isinstance(p, dict) and p['id'] not in all_child_ids] + queue.extend([p['id'] for p in members if isinstance(p, dict) and p['id'] not in queue]) + processed_count = 0 + max_process = len(members) * 2 + 5 + while queue and processed_count < max_process: + person_id = queue.pop(0) + processed_count += 1 + if person_id in visited: continue + person = id_to_person.get(person_id) + if not person: continue + totem_updated = False + current_totem = person.get('totem') + if current_totem is None or current_totem == "": + father_id = get_father_id(person_id, relationships, members) + if father_id: + father = id_to_person.get(father_id) + if father and father.get('totem') and (father_id in visited or father_id not in all_child_ids): + person['totem'] = father.get('totem') + totem_updated = True + visited.add(person_id) + for rel in relationships: + if isinstance(rel, dict) and rel.get('type') == 'parent' and rel.get('from_id') == person_id: + child_id = rel.get('to_id') + if child_id and child_id not in visited and child_id not in queue: + queue.append(child_id) + if totem_updated: + for rel in relationships: + if isinstance(rel, dict) and rel.get('type') == 'parent' and rel.get('from_id') == person_id: + child_id = rel.get('to_id') + if child_id and child_id in visited: + visited.remove(child_id) + if child_id not in queue: queue.append(child_id) + elif child_id and child_id not in queue: + queue.append(child_id) + if processed_count >= max_process: + app.logger.warning("WARN: Totem update BFS reached max iterations, potential loop?") + + +def generate_graphviz_object(data): # Renamed to avoid conflict if original is kept + dot = graphviz.Digraph(comment='Family Tree', format='svg') + dot.attr(rankdir='TB', splines='ortho', nodesep='0.6', ranksep='0.8') + theme = data.get("settings", {}).get("theme", "Default") + node_style = {'shape': 'box', 'style': 'filled', 'margin': '0.1'} + edge_color, marriage_node_color = 'gray50', 'gray50' + if theme == "Dark": + dot.attr(bgcolor='black', fontcolor='white'); node_style.update(fillcolor='grey30', fontcolor='white', color='white'); edge_color, marriage_node_color = 'white', 'white' + else: dot.attr(bgcolor='transparent'); node_style.update(fillcolor='lightblue', fontcolor='black', color='black') + members = data.get("family_members", []); relationships = data.get("relationships", []) + if not members: return dot, "No members to graph" + member_ids = {m['id'] for m in members if isinstance(m, dict)}; id_to_person = {p['id']: p for p in members if isinstance(p, dict)} + marriage_nodes = {}; parents_of_child = defaultdict(list); children_by_parent_pair = defaultdict(list) + for person in members: + if isinstance(person, dict): dot.node(person['id'], label=format_node_label(person), **node_style) + processed_spouses = set() + for rel in relationships: + if not isinstance(rel, dict): continue + from_id, to_id, rel_type = rel.get("from_id"), rel.get("to_id"), rel.get("type") + if from_id not in member_ids or to_id not in member_ids: continue + if rel_type == 'parent': parents_of_child[to_id].append(from_id) + elif rel_type == 'spouse': + pair = frozenset([from_id, to_id]) + if pair not in processed_spouses: + m_id = f"m_{uuid.uuid4().hex[:8]}"; marriage_nodes[pair] = m_id + dot.node(m_id, shape='point', width='0.1', height='0.1', label='', color=marriage_node_color) + dot.edge(from_id, m_id, style='invis', dir='none', weight='10') + dot.edge(to_id, m_id, style='invis', dir='none', weight='10') + with dot.subgraph(name=f"cluster_m_{m_id}") as sub: + sub.attr(rank='same', style='invis') + sub.node(from_id); sub.node(to_id) + processed_spouses.add(pair) + for child_id, parent_ids_list in parents_of_child.items(): + valid_p_ids = sorted([p_id for p_id in parent_ids_list if p_id in member_ids]); + if not valid_p_ids: continue + parent_key = frozenset(valid_p_ids); children_by_parent_pair[parent_key].append(child_id) + processed_child_links = set() + for parent_key, children_list in children_by_parent_pair.items(): + p_ids = list(parent_key); source_id = None + if len(p_ids) == 1: source_id = p_ids[0] + elif len(p_ids) > 1: source_id = marriage_nodes.get(parent_key) + if source_id: + for child_id in children_list: + if child_id in member_ids and (source_id, child_id) not in processed_child_links: + dot.edge(source_id, child_id, arrowhead='none', color=edge_color); processed_child_links.add((source_id, child_id)) + elif len(p_ids) > 1 and not source_id: + app.logger.warning(f"WARN: Missing marriage node for parents {p_ids}, linking child {children_list} from first parent.") + source_id = p_ids[0] + for child_id in children_list: + if child_id in member_ids and (source_id, child_id) not in processed_child_links: + dot.edge(source_id, child_id, arrowhead='none', color=edge_color); processed_child_links.add((source_id, child_id)) + for parent_key, siblings in children_by_parent_pair.items(): + valid_sibs = [sid for sid in siblings if sid in member_ids] + if len(valid_sibs) > 1: + with dot.subgraph(name=f"cluster_s_{uuid.uuid4().hex[:8]}") as sub: + sub.attr(rank='same', style='invis') + for sid in sorted(valid_sibs): sub.node(sid) + return dot, None + + +def safe_json_loads(text): + match = re.search(r"```(?:json)?\s*(\{.*\}|\[.*\])\s*```", text, re.DOTALL | re.IGNORECASE) + if match: json_text = match.group(1) + else: + start_brace, start_bracket = text.find('{'), text.find('[') + end_brace, end_bracket = text.rfind('}'), text.rfind(']') + start = min(start_brace, start_bracket) if start_brace != -1 and start_bracket != -1 else (start_brace if start_brace != -1 else start_bracket) + end = -1 + if start == start_brace and end_brace != -1: end = end_brace + elif start == start_bracket and end_bracket != -1: end = end_bracket + elif end_brace != -1 and end_bracket != -1: end = max(end_brace, end_bracket) + else: end = end_brace if end_brace != -1 else end_bracket + if start != -1 and end != -1 and end > start: json_text = text[start:end+1] + else: + json_text = text.strip() + if not ((json_text.startswith('{') and json_text.endswith('}')) or \ + (json_text.startswith('[') and json_text.endswith(']'))): + return None, f"Could not find JSON structure. Response: {text[:500]}..." + json_text = re.sub(r",\s*(\]|\})", r"\1", json_text) try: - verify_admin(request.headers.get('Authorization', '')) - - users_ref = db.reference('users') - all_users = users_ref.get() or {} - users_list = [] - for uid, user_data in all_users.items(): - try: - auth_user = auth.get_user(uid) - email = auth_user.email - except: - email = "Deleted User" - users_list.append({ - 'uid': uid, - 'email': email, - 'daily_cash': user_data.get('daily_cash', 0), - 'remaining_cash': user_data.get('remaining_cash', 0), - 'last_reset': user_data.get('last_reset'), - 'is_admin': user_data.get('is_admin', False) - }) - transactions_ref = db.reference('transactions') - all_transactions = transactions_ref.get() or {} - transactions_list = [{'id': tid, **data} for tid, data in all_transactions.items()] - return jsonify({ - 'users': users_list, - 'transactions': transactions_list, - 'analytics': { - 'total_users': len(users_list), - 'total_transactions': len(transactions_list), - 'total_spent': sum(t['total'] for t in transactions_list) - } - }) + return json.loads(json_text), None + except json.JSONDecodeError as e: + return None, f"Error parsing JSON: {e}. Attempted JSON: {json_text[:500]}..." except Exception as e: - return jsonify({'error': str(e)}), 500 + return None, f"Unexpected error during JSON parsing: {e}. Response: {text[:500]}..." -@app.route('/api/admin/users', methods=['POST']) -def create_user(): +def call_gemini(prompt_text, is_json_output_expected=True): + if not genai_client or api_key_error: + return None, "Gemini API not ready or API key error." try: - verify_admin(request.headers.get('Authorization', '')) - data = request.get_json() - - user = auth.create_user( - email=data['email'], - password=data['password'] - ) - - user_ref = db.reference(f'users/{user.uid}') - user_data = { - 'daily_cash': data.get('daily_cash', 0), - 'remaining_cash': data.get('daily_cash', 0), - 'last_reset': '2025-01-01T00:00:00+00:00', - 'is_admin': data.get('is_admin', False) - } - user_ref.set(user_data) - - return jsonify({ - 'success': True, - 'user': { - 'uid': user.uid, - 'email': user.email, - **user_data - } - }), 201 + model = genai.GenerativeModel(GEMINI_MODEL_NAME) + safety_settings = [ + {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"}, + {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"}, + {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"}, + {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"}, + ] + gen_config = genai.types.GenerationConfig(response_mime_type="application/json") if is_json_output_expected else None + response = model.generate_content(prompt_text, generation_config=gen_config, safety_settings=safety_settings) + + if not response.parts: + reason = "Unknown" + try: + reason = response.prompt_feedback.block_reason.name if hasattr(response, 'prompt_feedback') and response.prompt_feedback.block_reason else None + if not reason and response.candidates: reason = response.candidates[0].finish_reason.name + except Exception: pass + return None, f"AI response empty or blocked. Reason: {reason}" + if not hasattr(response, 'text') or not response.text: + return None, "AI response text empty." + + if is_json_output_expected: + parsed_json, err = safe_json_loads(response.text) + if err: return None, f"AI response received, but failed to parse as JSON: {err}. Raw: {response.text[:500]}..." + return parsed_json, None + else: + return response.text, None except Exception as e: - return jsonify({'error': str(e)}), 400 - -@app.route('/api/admin/users//limit', methods=['PUT']) -def update_user_limit(uid): + app.logger.error(f"Gemini API Call Error: {e} (Type: {type(e).__name__})") + return None, f"Gemini API Call Error: {e}" + + +def generate_tree_from_description_gemini(description): + prompt = f"""Please analyze the following family description. Extract individuals mentioned, including their name, and if available, their date of birth (dob), date of death (dod), gender (Male/Female/Other/Unknown), and totem. Also, identify direct relationships like parent_of, spouse_of, or sibling_of between these individuals. + +Format the output as a single JSON object containing two keys: +1. "people": A list of objects, where each object represents an individual and has keys for "name", "dob", "dod", "gender", and "totem" (use null or omit if information is not present). Use the name "Me" if the description uses first-person references without providing a name. +2. "relationships": A list of objects, where each object represents a relationship. Each relationship object should have "person1_name", "person2_name", and "type" (e.g., "parent_of", "spouse_of", "sibling_of"). Ensure the names match exactly those extracted in the "people" list. + +Strictly output only the JSON object, without any introductory text, explanations, or markdown formatting like ```json. + +Description: +"{description}" + +JSON Output: +""" + return call_gemini(prompt, is_json_output_expected=True) + +def generate_quiz_questions_gemini(members, relationships, num_questions=3): + if not members or len(members) < 2: return None, "Need at least 2 members for a quiz." + id_to_name = {p["id"]: p.get("name", "Unknown") for p in members if isinstance(p, dict)} + rel_strings, processed_pairs = [], set() + for rel in relationships: + if not isinstance(rel, dict): continue + p1_id, p2_id, rt = rel.get("from_id"), rel.get("to_id"), rel.get("type") + p1n, p2n = id_to_name.get(p1_id), id_to_name.get(p2_id) + if p1n and p2n and p1n != p2n: + pair = frozenset([p1_id, p2_id]) + if rt == "parent": rel_strings.append(f"'{p1n}' is a Parent of '{p2n}'") + elif rt == "spouse" and pair not in processed_pairs: rel_strings.append(f"'{p1n}' is a Spouse of '{p2n}'"); processed_pairs.add(pair) + elif rt == "sibling" and pair not in processed_pairs: rel_strings.append(f"'{p1n}' is a Sibling of '{p2n}'"); processed_pairs.add(pair) + if not rel_strings: return None, "No relationships found to base quiz questions on." + unique_names = set(id_to_name.values()) + min_required_names, actual_num_questions = 4, num_questions + if len(unique_names) < min_required_names: + if len(unique_names) >= 2: actual_num_questions = max(1, len(unique_names) - 1) + else: return None, "Need at least 2 unique names in the tree to generate a quiz." + prompt = f"""Based *only* on the provided list of family relationships and names, generate {actual_num_questions} unique multiple-choice quiz questions. + +Each question should test knowledge about one specific relationship. +The output format must be a single JSON list, where each element is an object representing a question: +`{{"text": "Question text?", "options": ["Correct Answer", "Wrong Option 1", "Wrong Option 2", "Wrong Option 3"], "correct": "Correct Answer"}}` + +- The "options" list must contain the correct answer and 3 incorrect answers chosen from the provided 'Names' list. +- All options within a single question must be unique names. +- If fewer than 4 unique names are available in the 'Names' list, use all available names as options, ensuring the correct answer is included. +- Do not invent relationships or information not present in the 'Relationships' list. +- Ensure the 'correct' value exactly matches one of the strings in the 'options' list. +- Strictly output only the JSON list, without any other text or markdown formatting. + +Names: +{chr(10).join(f"- {name}" for name in sorted(list(unique_names)))} + +Relationships: +{chr(10).join(f"- {rel}" for rel in rel_strings)} + +JSON Output: +""" + return call_gemini(prompt, is_json_output_expected=True) + +def generate_diff_summary(current_data, proposed_data): + summary = [] try: - verify_admin(request.headers.get('Authorization', '')) - data = request.get_json() - new_limit = float(data['daily_cash']) - - user_ref = db.reference(f'users/{uid}') - user_data = user_ref.get() - - if not user_data: - return jsonify({'error': 'User not found'}), 404 - - updates = {'daily_cash': new_limit} - current_remaining = user_data.get('remaining_cash', new_limit) - if current_remaining > new_limit: - updates['remaining_cash'] = new_limit - - user_ref.update(updates) - - return jsonify({ - 'success': True, - 'new_daily_cash': new_limit, - 'updated_remaining': updates.get('remaining_cash', current_remaining) - }) + # Use dictdiffer to find changes + result = list(diff(current_data, proposed_data, ignore={'last_edited_at', 'last_edited_by', 'created_at', 'created_by'})) # Ignore timestamps/editors for diff summary + + # Process members + current_members = {m['id']: m for m in current_data.get('family_members', []) if isinstance(m, dict)} + proposed_members = {m['id']: m for m in proposed_data.get('family_members', []) if isinstance(m, dict)} + added_members = set(proposed_members.keys()) - set(current_members.keys()) + deleted_members = set(current_members.keys()) - set(proposed_members.keys()) + common_members = set(current_members.keys()) & set(proposed_members.keys()) + + if added_members: + summary.append("**Members Added:**") + for mid in added_members: + summary.append(f"- {proposed_members[mid].get('name', 'Unnamed')} (ID: ...{mid[-6:]})") + if deleted_members: + summary.append("**Members Deleted:**") + for mid in deleted_members: + summary.append(f"- {current_members[mid].get('name', 'Unnamed')} (ID: ...{mid[-6:]})") + + modified_member_summary = [] + for mid in common_members: + member_diff = list(diff(current_members[mid], proposed_members[mid], ignore={'last_edited_at', 'last_edited_by', 'created_at', 'created_by', 'stories'})) # Ignore stories here, handle separately + if member_diff: + changes = [] + for change_type, path, values in member_diff: + field = path if isinstance(path, str) else path # Get field name + if change_type == 'change': changes.append(f"{field}: '{values}' -> '{values}'") + elif change_type == 'add': changes.append(f"{field}: added '{values}'") # Should be rare at top level + elif change_type == 'remove': changes.append(f"{field}: removed '{values}'") # Should be rare at top level + if changes: + modified_member_summary.append(f"- **{current_members[mid].get('name', 'Unnamed')}**: {'; '.join(changes)}") + if modified_member_summary: + summary.append("**Members Modified:**") + summary.extend(modified_member_summary) + + # Process Relationships (Simplified comparison) + current_rels = {(r.get('from_id'), r.get('to_id'), r.get('type')) for r in current_data.get('relationships', []) if isinstance(r, dict)} + proposed_rels = {(r.get('from_id'), r.get('to_id'), r.get('type')) for r in proposed_data.get('relationships', []) if isinstance(r, dict)} + added_rels = proposed_rels - current_rels + deleted_rels = current_rels - proposed_rels + + id_to_name_current = {m['id']: m.get('name', 'Unknown') for m in current_data.get('family_members', [])} + id_to_name_proposed = {m['id']: m.get('name', 'Unknown') for m in proposed_data.get('family_members', [])} + def format_rel(rel_tuple, names): + f_id, t_id, r_type = rel_tuple + f_name = names.get(f_id, f"...{f_id[-6:]}") + t_name = names.get(t_id, f"...{t_id[-6:]}") + return f"{f_name} {r_type} {t_name}" + + if added_rels: + summary.append("**Relationships Added:**") + for rel in added_rels: summary.append(f"- {format_rel(rel, id_to_name_proposed)}") + if deleted_rels: + summary.append("**Relationships Deleted:**") + for rel in deleted_rels: summary.append(f"- {format_rel(rel, id_to_name_current)}") + + # Process Stories (Simplified: check if stories list changed for any common member) + story_changes = [] + for mid in common_members: + current_stories = current_members[mid].get('stories', []) + proposed_stories = proposed_members[mid].get('stories', []) + # Simple check: compare lengths or string representations (not perfect but gives an idea) + if json.dumps(current_stories, sort_keys=True) != json.dumps(proposed_stories, sort_keys=True): + story_changes.append(f"- Stories for **{current_members[mid].get('name', 'Unnamed')}**") + if story_changes: + summary.append("**Stories Modified:**") + summary.extend(story_changes) except Exception as e: - return jsonify({'error': str(e)}), 400 + summary.append(f"Error generating diff: {e}") + return "\n".join(summary) if summary else "No significant changes detected." -# ======================================== -# New Admin Endpoints for Updating Remaining Cash, Setting Cash Limits, and Resetting Password -# ======================================== +# --- API Endpoints --- -@app.route('/api/admin/users//remaining-cash', methods=['PUT']) -def update_remaining_cash(uid): - try: - verify_admin(request.headers.get('Authorization', '')) - data = request.get_json() - if 'remaining_cash' not in data: - return jsonify({'error': 'remaining_cash is required'}), 400 - new_remaining_cash = float(data['remaining_cash']) - user_ref = db.reference(f'users/{uid}') - user_data = user_ref.get() - if not user_data: - return jsonify({'error': 'User not found'}), 404 - - user_ref.update({'remaining_cash': new_remaining_cash}) - return jsonify({'success': True, 'remaining_cash': new_remaining_cash}) - except Exception as e: - return jsonify({'error': str(e)}), 400 +# Helper to check for Firebase/API key errors (used by non-authed endpoints) +def check_system_health(): + if firebase_error: return jsonify({"error": "Firebase system error", "detail": firebase_error}), 503 + return None +@app.route("/health", methods=["GET"]) +def health_check(): + system_error_response = check_system_health() + if system_error_response: return system_error_response + if api_key_error: + return jsonify({"status": "Firebase OK, Gemini API Key Error"}), 200 + return jsonify({"status": "Firebase OK, Gemini OK"}), 200 + +# --- User/Auth related endpoints --- +@app.route('/user/me', methods=['GET']) +@token_required +def get_my_user_info(): + """ + Returns basic info about the authenticated user and their primary tree. + This also serves as a way to "register" or ensure the user's tree exists. + """ + current_user_phone = flask_g.user["phone_number"] + + # Load (or initialize) the user's primary tree data + tree_data, error = load_tree_data(current_user_phone) + if error: + # Specific check for initialization failure, which might be a server-side issue + if "Failed to initialize and save new tree" in error: + app.logger.error(f"Critical error initializing tree for {current_user_phone}: {error}") + return jsonify({"error": "Could not initialize user tree data", "detail": error}), 500 + # Other load errors might be less critical or indicate no data (which is fine if new) + app.logger.warning(f"Could not load tree data for {current_user_phone} during /user/me: {error}") + # If tree_data is None and it's not an init error, it implies a load issue post-init. + # However, load_tree_data is designed to create if None, so this path needs careful thought. + # For now, assume if tree_data is None after load_tree_data, it's a significant issue. + if tree_data is None: + return jsonify({"error": "Could not load user tree data", "detail": error}), 404 # Or 500 -@app.route('/api/admin/users//reset-password', methods=['PUT']) -def admin_reset_password(uid): + return jsonify({ + "uid": flask_g.user["uid"], + "phone_number": current_user_phone, + "primary_tree_metadata": tree_data.get("metadata") if tree_data else None + }), 200 + + +# --- Tree Data Endpoints --- +# Get a specific tree (can be own or another if part of it - auth handled by client if needed for "view") +# For simplicity, this endpoint is public for GET, but write operations on trees are protected. +@app.route('/tree/', methods=['GET']) +def get_tree_data_api(owner_phone_of_tree_to_view): + system_error_response = check_system_health() # Basic check + if system_error_response: return system_error_response + + norm_phone = normalize_phone(owner_phone_of_tree_to_view) + if not norm_phone: + return jsonify({"error": "Invalid owner_phone format"}), 400 + + tree_data, error = load_tree_data(norm_phone) + if error: + if tree_data is None and "Failed to initialize" not in error : # If it's not an init error but still no data + return jsonify({"error": "Tree data not found or could not be loaded.", "detail": error}), 404 + return jsonify({"error": "Could not load or initialize tree data", "detail": error}), 500 + return jsonify(tree_data), 200 + + +@app.route('/user/linked_trees', methods=['GET']) +@token_required +def get_linked_trees_api(): + """Gets trees the authenticated user is a member of (excluding their own primary tree).""" + current_user_phone = flask_g.user["phone_number"] + + linked_owner_phones_map, error = find_linked_trees(current_user_phone) + if error: + return jsonify({"error": "Could not fetch linked trees", "detail": error}), 500 + + result = [] + for owner_ph, status_val_in_index in linked_owner_phones_map.items(): + norm_owner_ph = normalize_phone(owner_ph) + if norm_owner_ph == current_user_phone: # Skip user's own tree + continue + if norm_owner_ph: + tree_d, err = load_tree_data(norm_owner_ph) + tree_name = tree_d.get("metadata", {}).get("tree_name", f"Tree by ...{norm_owner_ph[-4:]}") if tree_d and not err else f"Unknown Tree ({norm_owner_ph})" + result.append({"owner_phone": norm_owner_ph, "tree_name": tree_name}) + + return jsonify(result), 200 + + +@app.route('/tree//graph', methods=['GET']) +# This can remain public for viewing, or add @token_required if graphs should be private. +# For now, keeping it similar to get_tree_data_api (public GET). +def get_tree_graph_api(owner_phone_of_tree): + system_error_response = check_system_health() + if system_error_response: return system_error_response + norm_phone = normalize_phone(owner_phone_of_tree) + if not norm_phone: return jsonify({"error": "Invalid owner_phone format"}), 400 + + tree_data, error = load_tree_data(norm_phone) + if error or not tree_data: return jsonify({"error": "Could not load tree data for graph", "detail": error or "Tree data is empty"}), 404 + try: - verify_admin(request.headers.get('Authorization', '')) - data = request.get_json() - new_password = data.get('new_password') - if not new_password: - return jsonify({'error': 'new_password is required'}), 400 - auth.update_user(uid, password=new_password) - return jsonify({'success': True, 'message': 'Password reset successfully'}) + graph_dot, graph_err = generate_graphviz_object(tree_data) + if graph_err: return jsonify({"error": "Could not generate graph", "detail": graph_err}), 500 + + svg_data = graph_dot.pipe(format='svg').decode('utf-8') + return jsonify({"svg": svg_data, "dot_source": graph_dot.source}), 200 + except graphviz.backend.execute.ExecutableNotFound: + app.logger.error("Graphviz executable not found.") + return jsonify({"error": "Graphviz executable not found on server."}), 500 except Exception as e: - return jsonify({'error': str(e)}), 400 - + app.logger.error(f"Error generating graph SVG: {e}") + return jsonify({"error": "Error generating graph SVG", "detail": str(e)}), 500 + + +# --- Member Management Endpoints (Protected) --- +@app.route('/tree//members', methods=['POST']) +@token_required +def add_member_api(owner_phone_of_tree): + current_user_phone = flask_g.user["phone_number"] # Authenticated user + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format in URL"}), 400 + + # Authorization: Only tree owner can add members directly to their own tree. + # Collaborators use the proposal mechanism. + if current_user_phone != norm_owner_phone_of_tree: + return jsonify({"error": "Forbidden: You can only add members to your own tree directly. Use proposals for other trees."}), 403 + + req_data = request.json + if not req_data: return jsonify({"error": "Missing request body"}), 400 + new_member_info = req_data.get("member_data") + confirm_conflict = req_data.get("confirm_conflict", False) + if not new_member_info or not new_member_info.get("name"): + return jsonify({"error": "Missing member data or name"}), 400 + + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error: return jsonify({"error": "Could not load tree data", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) -@app.route('/api/admin/transactions/', methods=['DELETE']) -def delete_transaction(transaction_id): - """Allow admin users to delete transactions.""" - try: - verify_admin(request.headers.get('Authorization', '')) - transactions_ref = db.reference(f'transactions/{transaction_id}') - transaction_data = transactions_ref.get() + conflicting_members = find_person_by_name(tree_data, new_member_info["name"]) + if conflicting_members and not confirm_conflict: + return jsonify({ + "error": "Name conflict", + "message": f"A member named '{new_member_info['name']}' already exists.", + "conflicting_members": [{"id": m["id"], "name": m["name"]} for m in conflicting_members] + }), 409 + + new_member_id = generate_unique_id() + current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + norm_new_phone = normalize_phone(new_member_info.get("phone")) + if new_member_info.get("phone") and not norm_new_phone: + return jsonify({"error": "Invalid phone format for new member"}), 400 + + new_member_entry = deepcopy(DEFAULT_MEMBER_STRUCTURE) + new_member_entry.update({ + "id": new_member_id, + "name": new_member_info["name"].strip(), + "dob": new_member_info.get("dob", "").strip(), + "dod": new_member_info.get("dod", "").strip(), + "gender": new_member_info.get("gender", "Unknown"), + "phone": norm_new_phone or "", + "totem": new_member_info.get("totem", "").strip(), + "created_at": current_time, + "created_by": current_user_phone, # Action performed by authenticated user + "last_edited_at": current_time, + "last_edited_by": current_user_phone, + "stories": [] + }) + tree_data.setdefault("family_members", []).append(new_member_entry) - if not transaction_data: - return jsonify({'error': 'Transaction not found'}), 404 + save_success, save_error = save_tree_data(norm_owner_phone_of_tree, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save new member", "detail": save_error}), 500 + + response_message = "Member added successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message, "member": new_member_entry}), 201 - transactions_ref.delete() - return jsonify({'success': True, 'message': 'Transaction deleted successfully'}) - except Exception as e: - return jsonify({'error': str(e)}), 500 +@app.route('/tree//members/', methods=['PUT']) +@token_required +def edit_member_api(owner_phone_of_tree, member_id): + current_user_phone = flask_g.user["phone_number"] + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 -@app.route('/api/admin/transactions/', methods=['PUT']) -def edit_transaction(transaction_id): - """Allow admin users to edit transactions.""" - try: - verify_admin(request.headers.get('Authorization', '')) - transactions_ref = db.reference(f'transactions/{transaction_id}') - transaction_data = transactions_ref.get() + if current_user_phone != norm_owner_phone_of_tree: + return jsonify({"error": "Forbidden: You can only edit members in your own tree directly. Use proposals."}), 403 - if not transaction_data: - return jsonify({'error': 'Transaction not found'}), 404 + req_data = request.json + if not req_data: return jsonify({"error": "Missing request body"}), 400 + updated_info = req_data.get("member_data") + confirm_conflict = req_data.get("confirm_conflict", False) + if not updated_info: return jsonify({"error": "Missing member_data in request"}), 400 - update_data = request.get_json() - transactions_ref.update(update_data) + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error: return jsonify({"error": "Could not load tree data", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) + member_to_edit = find_person_by_id(tree_data, member_id) + if not member_to_edit: return jsonify({"error": "Member not found"}), 404 + + is_me_node_of_owner = (member_id == "Me" and member_to_edit.get("phone") == norm_owner_phone_of_tree) + if is_me_node_of_owner and "phone" in updated_info and normalize_phone(updated_info["phone"]) != norm_owner_phone_of_tree: + return jsonify({"error": "Cannot change the phone number of the owner's 'Me' node."}), 403 + if is_me_node_of_owner and "name" in updated_info and updated_info["name"] != member_to_edit.get("name"): + # Allow 'Me' node name change if it's done via profile update, but direct edit here might be restricted + # For now, let's assume profile endpoint handles 'Me' node name better. + # If name is part of profile sync, this direct edit might be redundant or conflicting. + # For simplicity, we allow it here but it should be consistent with profile logic. + pass + + + new_name = updated_info.get("name", member_to_edit.get("name")).strip() + if new_name != member_to_edit.get("name"): # Check if name actually changed + conflicting_members = [ + m for m in tree_data.get("family_members", []) + if m["id"] != member_id and m.get("name", "").strip().lower() == new_name.lower() + ] + if conflicting_members and not confirm_conflict: + return jsonify({ + "error": "Name conflict on edit", + "message": f"Changing name to '{new_name}' would conflict with an existing member.", + "conflicting_members": [{"id": m["id"], "name": m["name"]} for m in conflicting_members] + }), 409 + + something_changed = False + editable_fields = ["name", "dob", "dod", "gender", "totem", "phone"] + + for field in editable_fields: + if field in updated_info: + new_value_raw = updated_info[field] + new_value = new_value_raw.strip() if isinstance(new_value_raw, str) else new_value_raw + + if field == "phone": + if is_me_node_of_owner and new_value != norm_owner_phone_of_tree : # Already checked but good to be safe + continue # Skip phone change for owner's 'Me' node here + norm_new_phone = normalize_phone(new_value) + if new_value and not norm_new_phone: return jsonify({"error": f"Invalid phone format for field {field}"}), 400 + new_value = norm_new_phone or "" + + if member_to_edit.get(field) != new_value: + member_to_edit[field] = new_value + something_changed = True + + if something_changed: + member_to_edit["last_edited_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + member_to_edit["last_edited_by"] = current_user_phone + save_success, save_error = save_tree_data(norm_owner_phone_of_tree, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save updated member", "detail": save_error}), 500 + + response_message = "Member updated successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message, "member": member_to_edit}), 200 + else: + return jsonify({"message": "No changes detected for member.", "member": member_to_edit}), 200 + + +@app.route('/tree//members/', methods=['DELETE']) +@token_required +def delete_member_api(owner_phone_of_tree, member_id): + current_user_phone = flask_g.user["phone_number"] + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 + + if current_user_phone != norm_owner_phone_of_tree: + return jsonify({"error": "Forbidden: You can only delete members from your own tree directly."}), 403 + + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error: return jsonify({"error": "Could not load tree data", "detail": load_error}), 500 + + member_to_check = find_person_by_id(tree_data, member_id) + if not member_to_check: return jsonify({"error": "Member not found"}), 404 + if member_id == "Me" and member_to_check.get("phone") == norm_owner_phone_of_tree: + return jsonify({"error": "Cannot delete the owner's 'Me' user node."}), 403 + + original_tree_data_for_save = deepcopy(tree_data) + member_index = next((i for i, p in enumerate(tree_data.get("family_members", [])) if p.get("id") == member_id), -1) + # Already checked if member exists, so index should be found + + deleted_member_name = tree_data["family_members"][member_index].get("name", "Unknown") + del tree_data["family_members"][member_index] + tree_data["relationships"] = [ + r for r in tree_data.get("relationships", []) + if isinstance(r,dict) and r.get("from_id") != member_id and r.get("to_id") != member_id + ] + + save_success, save_error = save_tree_data(norm_owner_phone_of_tree, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save after deleting member", "detail": save_error}), 500 + + response_message = f"Member '{deleted_member_name}' deleted successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message}), 200 + + +# --- Relationship Management Endpoints (Protected) --- +@app.route('/tree//relationships', methods=['POST']) +@token_required +def add_relationship_api(owner_phone_of_tree): + current_user_phone = flask_g.user["phone_number"] + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 + + if current_user_phone != norm_owner_phone_of_tree: + return jsonify({"error": "Forbidden: You can only add relationships to your own tree directly."}), 403 + + req_data = request.json + if not req_data or not all(k in req_data for k in ["from_id", "to_id", "type"]): + return jsonify({"error": "Missing from_id, to_id, or type in request body"}), 400 + + from_id, to_id, rel_type = req_data["from_id"], req_data["to_id"], req_data["type"] + valid_rel_types = ['parent', 'spouse', 'sibling'] + if rel_type not in valid_rel_types: + return jsonify({"error": f"Invalid relationship type. Must be one of {valid_rel_types}"}), 400 + if from_id == to_id: + return jsonify({"error": "Cannot define a relationship between a person and themselves."}), 400 + + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error: return jsonify({"error": "Could not load tree data", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) + if not find_person_by_id(tree_data, from_id) or not find_person_by_id(tree_data, to_id): + return jsonify({"error": "One or both persons in the relationship not found."}), 404 + + relationships = tree_data.setdefault("relationships", []) + exists = False + for rel in relationships: + if not isinstance(rel, dict): continue + rf, rt, rtype_existing = rel.get('from_id'), rel.get('to_id'), rel.get('type') + if rel_type == 'parent' and rtype_existing == 'parent' and rf == from_id and rt == to_id: exists = True; break + if rel_type in ['spouse', 'sibling'] and rtype_existing == rel_type and frozenset([rf, rt]) == frozenset([from_id, to_id]): exists = True; break + if exists: + return jsonify({"error": "This relationship already exists."}), 409 + + new_rel_entry = {"from_id": from_id, "to_id": to_id, "type": rel_type} + relationships.append(new_rel_entry) + + save_success, save_error = save_tree_data(norm_owner_phone_of_tree, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save new relationship", "detail": save_error}), 500 + + response_message = "Relationship added successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message, "relationship": new_rel_entry}), 201 - return jsonify({'success': True, 'updated_transaction': update_data}) - except Exception as e: - return jsonify({'error': str(e)}), 500 +@app.route('/tree//relationships/delete', methods=['POST']) +@token_required +def delete_relationship_api(owner_phone_of_tree): + current_user_phone = flask_g.user["phone_number"] + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 -# ======================================== -# User management endpoint for profile -# ======================================== + if current_user_phone != norm_owner_phone_of_tree: + return jsonify({"error": "Forbidden: You can only delete relationships from your own tree directly."}), 403 + + req_data = request.json + if not req_data or not all(k in req_data for k in ["from_id", "to_id", "type"]): + return jsonify({"error": "Missing from_id, to_id, or type in request body for deletion"}), 400 + + del_from_id, del_to_id, del_rel_type = req_data["from_id"], req_data["to_id"], req_data["type"] -@app.route('/api/user/profile', methods=['GET']) -def get_user_profile(): - try: - uid = verify_token(request.headers.get('Authorization', '').split(' ')[1]) - user = auth.get_user(uid) - user_data = db.reference(f'users/{uid}').get() + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error: return jsonify({"error": "Could not load tree data", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) + relationships = tree_data.get("relationships", []) + new_relationships = [] + deleted = False + for rel in relationships: + if not isinstance(rel, dict): new_relationships.append(rel); continue + rf, rt, rtype = rel.get('from_id'), rel.get('to_id'), rel.get('type') + is_match = False + if del_rel_type == 'parent' and rtype == 'parent' and rf == del_from_id and rt == del_to_id: is_match = True + elif del_rel_type in ['spouse', 'sibling'] and rtype == del_rel_type and frozenset([rf, rt]) == frozenset([del_from_id, del_to_id]): is_match = True - return jsonify({ - 'uid': uid, - 'email': user.email, - 'daily_cash': user_data.get('daily_cash', 0), - 'remaining_cash': user_data.get('remaining_cash', 0), - 'last_reset': user_data.get('last_reset'), - 'is_admin': user_data.get('is_admin', False) - }) - except Exception as e: - uid = verify_token(request.headers.get('Authorization', '').split(' ')[1]) - user = auth.get_user(uid) - user_data = db.reference(f'users/{uid}').get() - return jsonify({'error': str(e)+ f'user data: {user_data}'}), 500 - -# ======================================== -# Receipt media endpoints -# ======================================== - -def get_blob_from_image_url(image_url): - parsed = urlparse(image_url) - if parsed.netloc == "storage.googleapis.com": - parts = parsed.path.strip("/").split("/", 1) - if len(parts) == 2: - bucket_name, blob_path = parts - return blob_path - prefix = f"/v0/b/{bucket.name}/o/" - if parsed.path.startswith(prefix): - encoded_blob_path = parsed.path[len(prefix):] - blob_path = unquote(encoded_blob_path) - return blob_path - return None + if is_match: deleted = True + else: new_relationships.append(rel) -@app.route('/api/admin/receipt//view', methods=['GET']) -def view_receipt(transaction_id): - try: - verify_admin(request.headers.get('Authorization', '')) - transaction_ref = db.reference(f'transactions/{transaction_id}') - transaction_data = transaction_ref.get() - if not transaction_data: - return jsonify({'error': 'Transaction not found'}), 404 - - image_url = transaction_data.get('image_url') - if not image_url: - return jsonify({'error': 'No receipt image found for this transaction'}), 404 - - blob_path = get_blob_from_image_url(image_url) - if not blob_path: - return jsonify({'error': 'Could not determine blob path from URL'}), 500 - - print(f"Blob path for view: {blob_path}") - blob = bucket.blob(blob_path) - if not blob.exists(): - print("Blob does not exist at path:", blob_path) - return jsonify({'error': 'Blob not found'}), 404 - - signed_url = blob.generate_signed_url(expiration=timedelta(minutes=10)) - r = requests.get(signed_url) - if r.status_code != 200: - return jsonify({'error': 'Unable to fetch image from storage'}), 500 - - return send_file(io.BytesIO(r.content), mimetype='image/jpeg') - except Exception as e: - print(f"View receipt error: {str(e)}") - return jsonify({'error': str(e)}), 500 + if not deleted: return jsonify({"error": "Relationship to delete not found."}), 404 -@app.route('/api/admin/receipt//download', methods=['GET']) -def download_receipt(transaction_id): - try: - verify_admin(request.headers.get('Authorization', '')) - transaction_ref = db.reference(f'transactions/{transaction_id}') - transaction_data = transaction_ref.get() - if not transaction_data: - return jsonify({'error': 'Transaction not found'}), 404 - - image_url = transaction_data.get('image_url') - if not image_url: - return jsonify({'error': 'No receipt image found for this transaction'}), 404 - - blob_path = get_blob_from_image_url(image_url) - if not blob_path: - return jsonify({'error': 'Could not determine blob path from URL'}), 500 - - print(f"Blob path for download: {blob_path}") - blob = bucket.blob(blob_path) - if not blob.exists(): - print("Blob does not exist at path:", blob_path) - return jsonify({'error': 'Blob not found'}), 404 - - signed_url = blob.generate_signed_url(expiration=timedelta(minutes=10)) - r = requests.get(signed_url) - if r.status_code != 200: - return jsonify({'error': 'Unable to fetch image from storage'}), 500 - - return send_file( - io.BytesIO(r.content), - mimetype='image/jpeg', - as_attachment=True, - attachment_filename='receipt.jpg' - ) - except Exception as e: - print(f"Download receipt error: {str(e)}") - return jsonify({'error': str(e)}), 500 + tree_data["relationships"] = new_relationships + save_success, save_error = save_tree_data(norm_owner_phone_of_tree, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save after deleting relationship", "detail": save_error}), 500 + + response_message = "Relationship deleted successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message}), 200 + + +# --- Story Management Endpoints (Protected) --- +@app.route('/tree//members//stories', methods=['POST']) +@token_required +def add_story_api(owner_phone_of_tree, member_id): + current_user_phone = flask_g.user["phone_number"] # Authenticated user adding the story + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 + + # Anyone authenticated can add a story to any member of any tree they can see/access. + # The "added_by" field will track who added it. + # If stricter control is needed (e.g., only tree owner or proposer), add checks here. + + req_data = request.json + if not req_data or "text" not in req_data: + return jsonify({"error": "Missing story text in request body"}), 400 + story_text = req_data["text"].strip() + if not story_text: return jsonify({"error": "Story text cannot be empty"}), 400 + + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error: return jsonify({"error": "Could not load tree data", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) # For save if current_user is owner + member = find_person_by_id(tree_data, member_id) + if not member: return jsonify({"error": "Member not found to add story to"}), 404 -# ======================================== -# Delete user endpoint -# ======================================== + if "stories" not in member or not isinstance(member["stories"], list): + member["stories"] = [] + + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + new_story_entry = deepcopy(DEFAULT_STORY_STRUCTURE) + new_story_entry.update({ + "timestamp": timestamp, "text": story_text, "added_by": current_user_phone + }) + member["stories"].append(new_story_entry) + member["last_edited_at"] = timestamp # Also update member's last edit + member["last_edited_by"] = current_user_phone # User who added story is last editor of member for this change + + # If the authenticated user is the owner of the tree, save directly. + # Otherwise, this change should be part of a proposal. + if current_user_phone == norm_owner_phone_of_tree: + save_success, save_error = save_tree_data(norm_owner_phone_of_tree, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save new story", "detail": save_error}), 500 + response_message = "Story added and saved successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message, "story": new_story_entry}), 201 + else: + # This endpoint is now for direct save by owner. Collaborators use /proposals. + # So, if not owner, this path shouldn't be hit for adding stories directly. + # However, if we allow anyone to add stories to any tree (public edit), this logic would change. + # For now, sticking to owner-edit or proposal. + # This implies that if a collaborator wants to add a story, they modify their copy of tree_data + # and then submit the entire tree_data via the /proposals endpoint. + return jsonify({"error": "Forbidden: Use proposals to add stories to trees you do not own."}), 403 + + +@app.route('/tree//members//stories/', methods=['DELETE']) +@token_required +def delete_story_api(owner_phone_of_tree, member_id, story_timestamp): + current_user_phone = flask_g.user["phone_number"] + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 + + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error: return jsonify({"error": "Could not load tree data", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) # For save if current_user is owner + member = find_person_by_id(tree_data, member_id) + if not member: return jsonify({"error": "Member not found"}), 404 + + stories = member.get("stories", []) + story_to_delete_index = -1 + for i, story in enumerate(stories): + if story.get("timestamp") == story_timestamp: + # Authorization: Only story adder or tree owner can delete. + can_delete = (story.get("added_by") == current_user_phone or current_user_phone == norm_owner_phone_of_tree) + if not can_delete: + return jsonify({"error": "Forbidden: You can only delete stories you added or if you are the tree owner."}), 403 + story_to_delete_index = i + break + + if story_to_delete_index == -1: + return jsonify({"error": "Story with given timestamp not found or you do not have permission to delete it."}), 404 + + del member["stories"][story_to_delete_index] + member["last_edited_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + member["last_edited_by"] = current_user_phone + + if current_user_phone == norm_owner_phone_of_tree: + save_success, save_error = save_tree_data(norm_owner_phone_of_tree, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save after deleting story", "detail": save_error}), 500 + response_message = "Story deleted successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message}), 200 + else: + # Similar to add story, direct delete is for owner. Collaborators use proposals. + return jsonify({"error": "Forbidden: Use proposals to delete stories from trees you do not own (unless you added the story and it's a direct delete)."}), 403 + + +# --- Collaboration Endpoints (Protected) --- +@app.route('/tree//proposals', methods=['POST']) +@token_required +def propose_changes_api(owner_phone_of_tree): + proposer_phone_from_token = flask_g.user["phone_number"] # This is the authenticated user making the proposal + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format in URL"}), 400 + if norm_owner_phone_of_tree == proposer_phone_from_token: + return jsonify({"error": "Cannot propose changes to your own tree. Edit directly."}), 400 + + req_data = request.json + # The "proposer_phone" in req_data is redundant if we use token, but client might send it. We trust the token. + if not req_data or "proposed_data" not in req_data: + return jsonify({"error": "Missing proposed_data in request"}), 400 + + proposed_data = req_data["proposed_data"] -@app.route('/api/admin/users/', methods=['DELETE']) -def delete_user(uid): - try: - verify_admin(request.headers.get('Authorization', '')) + success, error = propose_changes(norm_owner_phone_of_tree, proposer_phone_from_token, proposed_data) + if not success: + return jsonify({"error": "Failed to propose changes", "detail": error}), 500 + return jsonify({"message": "Changes proposed successfully."}), 201 + + +@app.route('/tree/my_proposals/pending', methods=['GET']) # Get pending proposals FOR the authenticated user's tree(s) +@token_required +def get_my_pending_changes_api(): + owner_phone_from_token = flask_g.user["phone_number"] # Authenticated user is the owner + + pending_data, error = load_pending_changes(owner_phone_from_token) + if error: + return jsonify({"error": "Could not load pending changes for your tree(s)", "detail": error}), 500 + return jsonify(pending_data), 200 + + +@app.route('/tree/my_proposals//accept', methods=['POST']) +@token_required +def accept_changes_api(proposer_phone_to_manage): + owner_phone_from_token = flask_g.user["phone_number"] # Authenticated user is the owner + norm_proposer_phone = normalize_phone(proposer_phone_to_manage) + if not norm_proposer_phone: return jsonify({"error": "Invalid proposer_phone_to_manage format"}), 400 + + success, error = accept_changes(owner_phone_from_token, norm_proposer_phone) + if not success: + return jsonify({"error": "Failed to accept changes", "detail": error}), 500 + return jsonify({"message": "Changes accepted and merged successfully."}), 200 + + +@app.route('/tree/my_proposals//reject', methods=['POST']) +@token_required +def reject_changes_api(proposer_phone_to_manage): + owner_phone_from_token = flask_g.user["phone_number"] # Authenticated user is the owner + norm_proposer_phone = normalize_phone(proposer_phone_to_manage) + if not norm_proposer_phone: return jsonify({"error": "Invalid proposer_phone_to_manage format"}), 400 + + success, error = reject_changes(owner_phone_from_token, norm_proposer_phone) + if not success: + return jsonify({"error": "Failed to reject changes", "detail": error}), 500 + return jsonify({"message": "Changes rejected successfully."}), 200 + +@app.route('/tree/my_proposals//diff', methods=['GET']) +@token_required +def get_proposal_diff_api(proposer_phone_to_review): + owner_phone_from_token = flask_g.user["phone_number"] # Authenticated user is the owner + norm_proposer_phone = normalize_phone(proposer_phone_to_review) + if not norm_proposer_phone: return jsonify({"error": "Invalid proposer_phone_to_review format"}), 400 + + current_owner_data, load_err = load_tree_data(owner_phone_from_token) + if load_err: return jsonify({"error": "Could not load current owner tree data", "detail": load_err}), 500 + + pending_proposals, pend_err = load_pending_changes(owner_phone_from_token) + if pend_err: return jsonify({"error": "Could not load pending proposals", "detail": pend_err}), 500 + + # The keys in pending_proposals are already normalized proposer phones + proposal_payload = pending_proposals.get(norm_proposer_phone) + if not proposal_payload or "tree_data" not in proposal_payload: + return jsonify({"error": f"Proposal from {norm_proposer_phone} not found or invalid."}), 404 + + proposed_data = proposal_payload["tree_data"] + diff_summary_text = generate_diff_summary(current_owner_data, proposed_data) + return jsonify({"diff_summary": diff_summary_text}), 200 + + +# --- AI Feature Endpoints (Protected as they operate on user's tree or consume user quota) --- +@app.route('/ai/build_tree_from_text', methods=['POST']) +@token_required # AI features should be protected +def ai_build_tree_api(): + # This endpoint doesn't directly modify a tree, just provides analysis. + # The owner_phone_of_tree context isn't strictly needed here unless we log usage against a tree. + # For now, it's a general utility for an authenticated user. + if api_key_error: return jsonify({"error": "Gemini API not configured"}), 503 + + req_data = request.json + if not req_data or "description" not in req_data: + return jsonify({"error": "Missing description in request body"}), 400 + description = req_data["description"] + + ai_result, error = generate_tree_from_description_gemini(description) + if error: + return jsonify({"error": "AI analysis failed", "detail": error}), 500 + return jsonify(ai_result), 200 + + +@app.route('/tree//ai_merge_suggestions', methods=['POST']) +@token_required +def ai_merge_tree_api(owner_phone_of_tree): + current_user_phone = flask_g.user["phone_number"] + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 + + if current_user_phone != norm_owner_phone_of_tree: + return jsonify({"error": "Forbidden: You can only merge AI suggestions into your own tree."}), 403 + if api_key_error: return jsonify({"error": "Gemini API features disabled."}), 503 + + + req_data = request.json + if not req_data or "ai_result" not in req_data: + return jsonify({"error": "Missing ai_result in request body"}), 400 + + ai_result_data = req_data["ai_result"] + if not isinstance(ai_result_data, dict) or "people" not in ai_result_data or "relationships" not in ai_result_data: + return jsonify({"error": "Invalid ai_result format"}), 400 + + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error: return jsonify({"error": "Could not load tree data for merge", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) + + # (Merge logic from previous version - slightly adapted for current_user_phone) + ai_people = ai_result_data.get("people", []) + ai_rels = ai_result_data.get("relationships", []) + valid_people = [p for p in ai_people if isinstance(p, dict) and p.get("name")] + valid_rel_structs = [r for r in ai_rels if isinstance(r, dict) and all(k in r for k in ["person1_name", "person2_name", "type"])] + ai_people_names = {p.get('name') for p in valid_people} + valid_rels_final = [r for r in valid_rel_structs if r.get('person1_name') in ai_people_names and r.get('person2_name') in ai_people_names] + + if not valid_people and not valid_rels_final: + return jsonify({"message": "No valid people or relationships from AI to merge."}), 200 + + added_p_count, added_r_count, updated_p_names, skipped_p_names, skipped_r_desc = 0, 0, [], [], [] + id_map = {} + current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + + for person_ai in valid_people: + ai_name = person_ai.get("name") + if not ai_name: continue + existing_people_with_name = find_person_by_name(tree_data, ai_name) + existing_person = existing_people_with_name if existing_people_with_name else None + person_updated = False + if existing_person: + id_map[ai_name] = existing_person['id'] + for key in ['dob', 'dod', 'gender', 'totem']: + if not existing_person.get(key) and person_ai.get(key): + if key == 'gender' and person_ai.get(key) == 'Unknown': continue + existing_person[key] = person_ai.get(key); person_updated = True + if person_updated: + existing_person["last_edited_at"] = current_time; existing_person["last_edited_by"] = current_user_phone + updated_p_names.append(ai_name) + else: skipped_p_names.append(ai_name + " (exists, no new info)") + else: + new_id = generate_unique_id(); id_map[ai_name] = new_id + new_data = deepcopy(DEFAULT_MEMBER_STRUCTURE) + valid_keys = ['name', 'dob', 'dod', 'gender', 'totem'] + new_data.update({k: v for k, v in person_ai.items() if k in valid_keys and v}) + new_data.update({"id": new_id, "created_at": current_time, "created_by": current_user_phone, + "last_edited_at": current_time, "last_edited_by": current_user_phone}) + tree_data.setdefault("family_members", []).append(new_data) + added_p_count += 1 + + current_rels_list = tree_data.setdefault("relationships", []) + existing_rel_set = set() + for r_exist in current_rels_list: # Build set of existing relationships + if not isinstance(r_exist, dict): continue + from_id_e, to_id_e, r_type_e = r_exist.get('from_id'), r_exist.get('to_id'), r_exist.get('type') + if not from_id_e or not to_id_e or not r_type_e: continue + if r_type_e == 'parent': existing_rel_set.add( (from_id_e, to_id_e, r_type_e) ) + elif r_type_e in ['spouse', 'sibling']: existing_rel_set.add( (tuple(sorted((from_id_e, to_id_e))), r_type_e) ) + + rel_type_map = {"parent_of":'parent', "spouse_of":'spouse', "sibling_of":'sibling'} + for rel_ai in valid_rels_final: + p1n, p2n, rta = rel_ai.get("person1_name"), rel_ai.get("person2_name"), rel_ai.get("type") + id1, id2 = id_map.get(p1n), id_map.get(p2n) + rti = rel_type_map.get(rta) + if id1 and id2 and rti: + exists, rel_key = False, None + if rti == 'parent': rel_key = (id1, id2, rti) + elif rti in ['spouse', 'sibling']: rel_key = (tuple(sorted((id1, id2))), rti) + if rel_key and rel_key in existing_rel_set: exists = True + if exists: skipped_r_desc.append(f"{p1n} {rta.replace('_',' ')} {p2n} (exists)") + else: + current_rels_list.append({"from_id": id1, "to_id": id2, "type": rti}); added_r_count += 1 + if rel_key: existing_rel_set.add(rel_key) + else: skipped_r_desc.append(f"{p1n} {rta.replace('_',' ')} {p2n} (missing person ID or invalid type)") + + if added_p_count > 0 or added_r_count > 0 or updated_p_names: + save_success, save_error = save_tree_data(norm_owner_phone_of_tree, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save merged AI data", "detail": save_error}), 500 + merge_summary_msg = f"AI Merge: Added {added_p_count} people, {added_r_count} relationships. Updated {len(updated_p_names)} people." + if save_error: merge_summary_msg += f" Warning: {save_error}" + return jsonify({"message": merge_summary_msg, "skipped_people": skipped_p_names, "skipped_relationships": skipped_r_desc}), 200 + else: + return jsonify({"message": "No new information from AI to merge.", "skipped_people": skipped_p_names, "skipped_relationships": skipped_r_desc}), 200 + + +@app.route('/tree//quiz/generate', methods=['POST']) +@token_required # Quiz generation might be resource-intensive or use API quotas +def generate_quiz_api(owner_phone_of_tree): + if api_key_error: return jsonify({"error": "Gemini API not configured"}), 503 + norm_owner_phone_of_tree = normalize_phone(owner_phone_of_tree) + if not norm_owner_phone_of_tree: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 + + # Authenticated user can generate quiz for any tree they can view. + # The owner_phone_of_tree in URL specifies which tree's data to use. + + num_questions = request.json.get("num_questions", 5) if request.json else 5 + + tree_data, load_error = load_tree_data(norm_owner_phone_of_tree) + if load_error or not tree_data: return jsonify({"error": "Could not load tree data for quiz", "detail": load_error or "Tree data is empty"}), 500 + + members = tree_data.get("family_members", []) + relationships = tree_data.get("relationships", []) + + questions, error = generate_quiz_questions_gemini(members, relationships, num_questions=num_questions) + if error: return jsonify({"error": "Failed to generate quiz questions", "detail": error}), 500 + if not questions or not isinstance(questions, list) or len(questions) == 0: + return jsonify({"error": "AI returned no valid questions or in an unexpected format."}), 500 + + valid_qs = [q for q in questions if isinstance(q, dict) and all(k in q for k in ['text','options','correct']) and isinstance(q['options'],list) and len(q['options']) > 1 and q['correct'] in q['options']] + if not valid_qs: + app.logger.error(f"AI Quiz Response Invalid Structure: {questions}") + return jsonify({"error": "AI returned questions in an invalid structure."}), 500 - try: - user = auth.get_user(uid) - except auth.UserNotFoundError: - return jsonify({'error': 'User not found'}), 404 + return jsonify(valid_qs), 200 + + +# --- Settings & Profile Endpoints (Protected, for authenticated user's own tree) --- +@app.route('/user/me/settings', methods=['PUT']) +@token_required +def update_my_settings_api(): + current_user_phone = flask_g.user["phone_number"] # Settings are for the authenticated user's own tree + + req_data = request.json + if not req_data: return jsonify({"error": "Missing request body for settings"}), 400 - auth.delete_user(uid) - db.reference(f'users/{uid}').delete() + tree_data, load_error = load_tree_data(current_user_phone) # Load user's own tree + if load_error: return jsonify({"error": "Could not load tree data for settings", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) + settings = tree_data.setdefault("settings", deepcopy(DEFAULT_PROFILE["settings"])) + metadata = tree_data.setdefault("metadata", deepcopy(DEFAULT_PROFILE["metadata"])) + changed = False + + if "tree_name" in req_data and metadata.get("tree_name") != req_data["tree_name"]: + metadata["tree_name"] = req_data["tree_name"]; changed = True + if "theme" in req_data and settings.get("theme") != req_data["theme"]: + settings["theme"] = req_data["theme"]; changed = True + if "privacy" in req_data and settings.get("privacy") != req_data["privacy"]: + settings["privacy"] = req_data["privacy"]; changed = True # Conceptual + + if changed: + save_success, save_error = save_tree_data(current_user_phone, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save settings", "detail": save_error}), 500 + response_message = "Settings updated successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message, "settings": settings, "metadata": metadata}), 200 + else: + return jsonify({"message": "No changes made to settings."}), 200 + + +@app.route('/user/me/profile', methods=['PUT']) +@token_required +def update_my_profile_api(): + current_user_phone = flask_g.user["phone_number"] # Profile is for the authenticated user's own tree + + req_data = request.json + if not req_data: return jsonify({"error": "Missing request body for profile"}), 400 + + tree_data, load_error = load_tree_data(current_user_phone) + if load_error: return jsonify({"error": "Could not load tree data for profile", "detail": load_error}), 500 + + original_tree_data_for_save = deepcopy(tree_data) + profile = tree_data.setdefault("profile", deepcopy(DEFAULT_PROFILE["profile"])) + profile_updated, me_node_updated = False, False + + # Update profile section + if "name" in req_data and profile.get("name") != req_data["name"]: + profile["name"] = req_data["name"]; profile_updated = True + if "dob" in req_data and profile.get("dob") != req_data["dob"]: + profile["dob"] = req_data["dob"]; profile_updated = True + if "gender" in req_data and profile.get("gender") != req_data["gender"]: + profile["gender"] = req_data["gender"]; profile_updated = True + + # Sync relevant profile changes to the 'Me' node in family_members + me_node = find_person_by_id(tree_data, "Me") + if me_node and me_node.get("phone") == current_user_phone: # Ensure it's the correct 'Me' node + # Use profile name for 'Me' node if available and different, else keep 'Me' or existing name + me_node_name_update = profile.get("name") if profile.get("name") else me_node.get("name", "Me") + if me_node.get("name") != me_node_name_update: me_node["name"] = me_node_name_update; me_node_updated = True - transactions_ref = db.reference('transactions') - user_transactions = transactions_ref.order_by_child('uid').equal_to(uid).get() - if user_transactions: - for transaction_id in user_transactions.keys(): - transactions_ref.child(transaction_id).delete() + if "dob" in req_data and me_node.get("dob") != req_data["dob"]: + me_node["dob"] = req_data["dob"]; me_node_updated = True + if "gender" in req_data and me_node.get("gender") != req_data["gender"]: + me_node["gender"] = req_data["gender"]; me_node_updated = True - return jsonify({ - 'success': True, - 'message': f'User {uid} and all associated data deleted successfully' - }) - except Exception as e: - return jsonify({'error': str(e)}), 500 + if me_node_updated: + me_node["last_edited_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + me_node["last_edited_by"] = current_user_phone + elif not me_node: + app.logger.warning(f"Could not find 'Me' node for owner {current_user_phone} to sync profile.") + + if profile_updated or me_node_updated: + save_success, save_error = save_tree_data(current_user_phone, tree_data, original_tree_data_for_save) + if not save_success: + return jsonify({"error": "Failed to save profile updates", "detail": save_error}), 500 + response_message = "Profile updated successfully." + if save_error: response_message += f" Warning: {save_error}" + return jsonify({"message": response_message, "profile": profile, "me_node_updated": me_node_updated}), 200 + else: + return jsonify({"message": "No changes made to profile."}), 200 + +# --- Family Timeline Endpoint (Public GET or @token_required if private) --- +@app.route('/tree//timeline', methods=['GET']) +def get_timeline_api(owner_phone_of_tree): + system_error_response = check_system_health() + if system_error_response: return system_error_response + norm_phone = normalize_phone(owner_phone_of_tree) + if not norm_phone: return jsonify({"error": "Invalid owner_phone_of_tree format"}), 400 + + tree_data, load_error = load_tree_data(norm_phone) + if load_error or not tree_data: return jsonify({"error": "Could not load tree data for timeline", "detail": load_error or "Tree data is empty"}), 500 + + members = tree_data.get("family_members", []) + events = [] + valid_date_format = "%Y-%m-%d" + for person in members: + if not isinstance(person, dict): continue + name = person.get("name", "Unknown") + dob_str, dod_str = person.get("dob"), person.get("dod") + try: + if dob_str: + datetime.strptime(dob_str, valid_date_format) # Validate format + events.append({"date": dob_str, "type": "Birth", "desc": f"{name} born."}) + if dod_str: + datetime.strptime(dod_str, valid_date_format) # Validate format + events.append({"date": dod_str, "type": "Death", "desc": f"{name} passed."}) + except (ValueError, TypeError): pass + + try: events.sort(key=lambda x: x.get("date", "0000-00-00")) + except Exception as e: app.logger.warning(f"Timeline sort error: {e}.") + + return jsonify(events), 200 + -if __name__ == '__main__': - app.run(debug=True, host="0.0.0.0", port=7860) +# --------- Run the App --------- +if __name__ == "__main__": + app.run(host="0.0.0.0", port=7860, debug=True) \ No newline at end of file