# -*- 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 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, 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) # 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("Gemini") # --- 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}") # --- UID to Phone Mapping Functions (NEW for email auth) --- def get_uid_phone_mapping_path(uid): """Get the Firebase path for storing user's phone number by UID""" return f'users_by_uid/{uid}' def get_user_phone_by_uid(uid): """Look up a user's phone number from their UID""" if firebase_error or not firebase_db_ref: return None, firebase_error or "Firebase not initialized" try: path = get_uid_phone_mapping_path(uid) data = firebase_db_ref.child(path).get() if data and isinstance(data, dict): return data.get('phone_number'), None return None, "Phone number not linked for this user" except Exception as e: return None, f"Error looking up phone: {e}" def set_user_phone_by_uid(uid, phone_number, display_name=None, email=None): """Store a user's phone number mapping by UID""" if firebase_error or not firebase_db_ref: return False, firebase_error or "Firebase not initialized" norm_phone = normalize_phone(phone_number) if not norm_phone: return False, "Invalid phone number format" try: path = get_uid_phone_mapping_path(uid) user_data = { 'phone_number': norm_phone, 'linked_at': datetime.now().strftime("%Y-%m-%d %H:%M:%S") } if display_name: user_data['display_name'] = display_name if email: user_data['email'] = email firebase_db_ref.child(path).set(user_data) return True, None except Exception as e: return False, f"Error saving phone mapping: {e}" # --- Authentication Decorator (UPDATED for email auth) --- 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 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 id_token = auth_header.split('Bearer ')[1] try: decoded_token = firebase_auth.verify_id_token(id_token) uid = decoded_token.get('uid') email = decoded_token.get('email') # First check if phone is in the token (legacy phone auth) phone_from_token = decoded_token.get('phone_number') if phone_from_token: # Legacy phone authentication phone_number = normalize_phone(phone_from_token) if not phone_number: app.logger.error(f"Failed to normalize phone number from token for UID {uid}.") return jsonify({"error": "Invalid phone number format in token."}), 403 flask_g.user = { "uid": uid, "email": email, "phone_number": phone_number, "phone_linked": True } else: # Email authentication - look up phone from database phone_number, lookup_error = get_user_phone_by_uid(uid) if not phone_number: # Phone not yet linked - allow access but mark as unlinked flask_g.user = { "uid": uid, "email": email, "phone_number": None, "phone_linked": False } else: flask_g.user = { "uid": uid, "email": email, "phone_number": phone_number, "phone_linked": True } 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 return f(*args, **kwargs) return decorated_function def phone_required(f): """Decorator for endpoints that require a linked phone number""" @wraps(f) def decorated_function(*args, **kwargs): if not flask_g.user.get("phone_linked") or not flask_g.user.get("phone_number"): return jsonify({ "error": "Phone number not linked", "message": "Please link your phone number to access this feature.", "action_required": "link_phone" }), 403 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: 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: app.logger.error(f"Error loading tree data for {norm_owner_phone_to_load}: {e}") return None, f"Error loading tree data: {e}" 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: 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: 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: 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}" # --- 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." 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." 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) try: 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 norm_owner_phone_of_tree or not norm_proposer_phone: return False, "Invalid owner or proposer phone format for proposing changes." 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." 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: 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." pending_base_path = get_pending_changes_path(norm_owner_phone) if not pending_base_path: return {}, "Failed to generate pending base path." try: data = firebase_db_ref.child(pending_base_path).get() return data if data and isinstance(data, dict) else {}, None except Exception as e: app.logger.error(f"Error loading pending changes for {norm_owner_phone}: {e}") return {}, f"Error loading pending changes: {e}" # 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" 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." 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." try: 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: app.logger.error(f"Error accepting changes from {norm_proposer_phone}: {e}") return False, f"Error accepting changes: {e}" # 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) 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: firebase_db_ref.child(pending_path).delete() return True, None except Exception as e: 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 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 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: 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 None, f"Unexpected error during JSON parsing: {e}. Response: {text[:500]}..." 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: 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: 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: # 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:]})") # Check for edited members edited_summary = [] for mid in common_members: curr_m, prop_m = current_members[mid], proposed_members[mid] changes = [] for key in ['name', 'dob', 'dod', 'gender', 'totem', 'phone']: if curr_m.get(key) != prop_m.get(key): changes.append(f"{key}: '{curr_m.get(key)}' -> '{prop_m.get(key)}'") # Story changes curr_stories = set(s.get('timestamp') for s in curr_m.get('stories', []) if isinstance(s, dict)) prop_stories = set(s.get('timestamp') for s in prop_m.get('stories', []) if isinstance(s, dict)) if curr_stories != prop_stories: added_s = len(prop_stories - curr_stories) removed_s = len(curr_stories - prop_stories) if added_s > 0: changes.append(f"{added_s} storie(s) added") if removed_s > 0: changes.append(f"{removed_s} storie(s) removed") if changes: edited_summary.append(f"- {curr_m.get('name', 'Unnamed')} (ID: ...{mid[-6:]}): {', '.join(changes)}") if edited_summary: summary.append("**Members Edited:**") summary.extend(edited_summary) # Process relationships curr_rels = set(tuple(sorted([r['from_id'],r['to_id']])) + (r['type'],) for r in current_data.get('relationships', []) if isinstance(r, dict) and all(k in r for k in ['from_id', 'to_id', 'type'])) prop_rels = set(tuple(sorted([r['from_id'],r['to_id']])) + (r['type'],) for r in proposed_data.get('relationships', []) if isinstance(r, dict) and all(k in r for k in ['from_id', 'to_id', 'type'])) added_rels = prop_rels - curr_rels deleted_rels = curr_rels - prop_rels if added_rels: summary.append("**Relationships Added:**") for rel_tuple in added_rels: name1 = proposed_members.get(rel_tuple[0], {}).get('name', f'...{rel_tuple[0][-6:]}') name2 = proposed_members.get(rel_tuple[1], {}).get('name', f'...{rel_tuple[1][-6:]}') summary.append(f"- {name1} <--> {name2} ({rel_tuple[2]})") if deleted_rels: summary.append("**Relationships Deleted:**") for rel_tuple in deleted_rels: name1 = current_members.get(rel_tuple[0], {}).get('name', f'...{rel_tuple[0][-6:]}') name2 = current_members.get(rel_tuple[1], {}).get('name', f'...{rel_tuple[1][-6:]}') summary.append(f"- {name1} <--> {name2} ({rel_tuple[2]})") # Settings/Metadata changes settings_changes = [] if current_data.get('settings', {}).get('theme') != proposed_data.get('settings', {}).get('theme'): settings_changes.append(f"Theme: '{current_data.get('settings', {}).get('theme')}' -> '{proposed_data.get('settings', {}).get('theme')}'") if current_data.get('metadata', {}).get('tree_name') != proposed_data.get('metadata', {}).get('tree_name'): settings_changes.append(f"Tree Name: '{current_data.get('metadata', {}).get('tree_name')}' -> '{proposed_data.get('metadata', {}).get('tree_name')}'") if settings_changes: summary.append("**Settings/Metadata Changed:**") summary.extend([f"- {c}" for c in settings_changes]) if not summary: return "No significant changes detected." return "\n".join(summary) except Exception as e: app.logger.error(f"Error generating diff summary: {e}") return f"Error generating diff summary: {e}" # --- System Health Check Helper --- def check_system_health(): if firebase_error: return jsonify({"error": "Firebase not available", "detail": firebase_error}), 503 if not firebase_db_ref: return jsonify({"error": "Firebase database reference not set."}), 503 return None # ======================= API Endpoints ======================= @app.route('/health', methods=['GET']) def health_check(): status = { "status": "ok", "firebase": "ok" if not firebase_error and firebase_db_ref else f"error: {firebase_error or 'DB ref not set'}", "gemini_api": "ok" if not api_key_error and genai_client else "error or not configured" } overall_ok = status["firebase"] == "ok" return jsonify(status), 200 if overall_ok else 503 # --- NEW: User Management Endpoints for Email Auth --- @app.route('/user/me', methods=['GET']) @token_required def get_current_user_api(): """Get the authenticated user's information""" uid = flask_g.user["uid"] email = flask_g.user.get("email") phone_number = flask_g.user.get("phone_number") phone_linked = flask_g.user.get("phone_linked", False) response = { "uid": uid, "email": email, "phone_number": phone_number, "phone_linked": phone_linked } # If phone is linked, get additional user info and primary tree if phone_linked and phone_number: tree_data, _ = load_tree_data(phone_number) if tree_data: response["display_name"] = tree_data.get("profile", {}).get("name") response["primary_tree"] = { "owner_phone": phone_number, "tree_name": tree_data.get("metadata", {}).get("tree_name", "My Family Tree"), "created_at": tree_data.get("metadata", {}).get("created_at") } else: # Get display name from uid mapping if available try: path = get_uid_phone_mapping_path(uid) user_data = firebase_db_ref.child(path).get() if user_data and isinstance(user_data, dict): response["display_name"] = user_data.get("display_name") except Exception: pass return jsonify(response), 200 @app.route('/user/link_phone', methods=['POST']) @token_required def link_phone_api(): """Link a phone number to the authenticated user's account""" uid = flask_g.user["uid"] email = flask_g.user.get("email") # Check if phone is already linked if flask_g.user.get("phone_linked"): return jsonify({ "message": "Phone number already linked", "phone_number": flask_g.user.get("phone_number") }), 200 req_data = request.json if not req_data or "phone_number" not in req_data: return jsonify({"error": "Missing phone_number in request body"}), 400 phone_number = req_data["phone_number"] display_name = req_data.get("display_name") # Validate phone format norm_phone = normalize_phone(phone_number) if not norm_phone: return jsonify({"error": "Invalid phone number format. Use +263... format."}), 400 # Check if this phone is already linked to another user try: all_users = firebase_db_ref.child('users_by_uid').get() if all_users: for existing_uid_key, user_data in all_users.items(): if isinstance(user_data, dict) and user_data.get('phone_number') == norm_phone: if existing_uid_key != uid: return jsonify({ "error": "Phone number already linked", "message": "This phone number is already linked to another account." }), 409 except Exception as e: app.logger.warning(f"Could not check for existing phone links: {e}") # Store the phone mapping success, error = set_user_phone_by_uid(uid, norm_phone, display_name, email) if not success: return jsonify({"error": "Failed to link phone number", "detail": error}), 500 # Initialize user's tree if it doesn't exist tree_data, load_error = load_tree_data(norm_phone) if load_error and "Failed to initialize" in load_error: return jsonify({"error": "Phone linked but tree initialization failed", "detail": load_error}), 500 # Update profile name if display_name provided if display_name and tree_data: tree_data["profile"]["name"] = display_name me_node = find_person_by_id(tree_data, "Me") if me_node: me_node["name"] = display_name me_node["last_edited_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") me_node["last_edited_by"] = norm_phone save_tree_data(norm_phone, tree_data, tree_data) return jsonify({ "message": "Phone number linked successfully", "phone_number": norm_phone, "tree_initialized": tree_data is not None }), 200 # --- Tree Data Endpoints --- @app.route('/tree/', methods=['GET']) def get_tree_data_api(owner_phone): system_error_response = check_system_health() if system_error_response: return system_error_response norm_phone = normalize_phone(owner_phone) 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.get("phone_number") # Handle unlinked phone users gracefully if not current_user_phone: return jsonify({ "message": "Link your phone number to see linked trees", "trees": [], "action_required": "link_phone" }), 200 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: 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: 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 @phone_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) 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) 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 @app.route('/tree//members/', methods=['PUT']) @token_required @phone_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 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 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 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 @phone_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 @phone_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 @app.route('/tree//relationships/delete', methods=['POST']) @token_required @phone_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 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"] 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 if is_match: deleted = True else: new_relationships.append(rel) if not deleted: return jsonify({"error": "Relationship to delete not found."}), 404 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 @phone_required def add_story_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 req_data = request.json if not req_data or "text" not in req_data or not req_data["text"].strip(): return jsonify({"error": "Missing or empty 'text' for story"}), 400 story_text = req_data["text"].strip() 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 new_story = { "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "text": story_text, "added_by": current_user_phone } member.setdefault("stories", []).append(new_story) member["last_edited_at"] = new_story["timestamp"] member["last_edited_by"] = current_user_phone if current_user_phone == norm_owner_phone_of_tree: # Owner adds story directly 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 story", "detail": save_error}), 500 response_message = "Story added successfully." if save_error: response_message += f" Warning: {save_error}" return jsonify({"message": response_message, "story": new_story}), 201 else: # Collaborator adds story: For simplicity, let's allow collaborators to add stories directly for now. # A more strict approach would be to use proposals for all changes. # Here, we allow stories to be added by non-owners as a contribution. # The story will have `added_by` set to the collaborator's phone. # Tree owner can delete it later if needed. 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 story (as collaborator)", "detail": save_error}), 500 response_message = "Story added successfully (as collaborator)." if save_error: response_message += f" Warning: {save_error}" return jsonify({"message": response_message, "story": new_story}), 201 @app.route('/tree//members//stories/', methods=['DELETE']) @token_required @phone_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 @phone_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"] 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 @phone_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 @phone_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 @phone_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 @phone_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 @phone_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[0] 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 return jsonify(valid_qs), 200 # --- Settings & Profile Endpoints (Protected, for authenticated user's own tree) --- @app.route('/user/me/settings', methods=['PUT']) @token_required @phone_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 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 @phone_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 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 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 # --------- Run the App --------- if __name__ == "__main__": app.run(host="0.0.0.0", port=7860, debug=True)