Merge pull request #9 from marshfellow42/main

Enviar a maioria das mudanças que eu fiz

Author: marshfellow42

api/main.py

@@ -1,4 +1,5 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import RedirectResponse
 import firebase_admin
 from firebase_admin import credentials, db, auth
 import phonenumbers
@@ -7,6 +8,8 @@
 from datetime import datetime
 import os
 from dotenv import load_dotenv
+import random
+import string
 
 load_dotenv()
 
@@ -27,7 +30,7 @@
 firebase_admin.initialize_app(cred, {"databaseURL": os.getenv("DATABASE_URL")})
 
 ref = db.reference("/")
-agenda_ref = ref.child('agenda')
+agenda_ref = ref.child('agendas')
 
 def to_e164_br(phone_number):
     try:
@@ -46,6 +49,30 @@ def timestamp_formatado(timestamp):
     except ValueError:
         raise HTTPException(status_code=400, detail="Formato de timestamp inválido. Use ISO 8601 (ex: '2025-06-27T14:00:00')")
 
+def check_uid_exists(uid: str):
+    try:
+        user = auth.get_user(uid)
+        print(f"✅ User exists: {user.uid}, email: {user.email}")
+        return True
+    except auth.UserNotFoundError:
+        print("❌ No user found with that UID.")
+        return False
+    except Exception as e:
+        print(f"⚠️ Error: {e}")
+        return False
+
+def generate_random_invite_url(length: int = 12) -> str:
+    chars = string.ascii_letters + string.digits  # A-Z, a-z, 0-9
+    return ''.join(random.choices(chars, k=length))
+
+STANDARD_RESPONSES = {
+    400: {"description": "Bad Request"},
+    401: {"description": "Unauthorized"},
+    403: {"description": "Forbidden"},
+    404: {"description": "Not Found"},
+    500: {"description": "Internal Server Error"},
+}
+
 tags_metadata = [
     {
         "name": "Usuários",
@@ -63,34 +90,69 @@ def timestamp_formatado(timestamp):
 def read_root():
     return {"Hello": "World"}
 
-@app.get("/testFirebase")
+@app.get("/testFirebase", responses=STANDARD_RESPONSES)
 def testar_o_firebase():
     try:
         if ref.get():
             message = "Conectado com successo ao Firebase"
+            return {"message": message}
     except Exception as e:
-        message = f"Falha ao se conectar com o Firebase: {str(e)}"
-    return {"message": message}
+        raise HTTPException(status_code=500, detail=f"Falha ao se conectar com o Firebase: {str(e)}")
+
+from fastapi import APIRouter
+
+@app.get("/invite/{uid_da_agenda}", responses=STANDARD_RESPONSES)
+def mandar_um_convite_para_entrar_na_turma_tipo_o_whatsapp(uid_da_agenda: str, request: Request):
+    agenda_node = agenda_ref.child(uid_da_agenda)
+    agenda_data = agenda_node.get()
+
+    if not agenda_data:
+        raise HTTPException(status_code=404, detail=f"A agenda com o UID {uid_da_agenda} não existe")
 
-@app.get("/getAllUsers/", tags=["Usuários"])
+    # Detecta o dispositivo
+    user_agent = request.headers.get("user-agent", "").lower()
+
+    # Deep link do seu app (Expo deve estar configurado com "scheme": "cosmos")
+    deep_link_url = "cosmos://home"
+
+    # URL da Play Store (o pacote deve bater com o app.json do Expo)
+    play_store_url = "https://play.google.com/store/apps/details?id=com.seuapp.android"
+
+    if "android" in user_agent:
+        intent_url = (
+            f"intent://home#Intent;"
+            f"scheme=cosmos;"
+            f"package=com.seuapp.android;"
+            f"end"
+        )
+        return RedirectResponse(intent_url)
+
+    elif "iphone" in user_agent or "ipad" in user_agent:
+        return RedirectResponse(deep_link_url)
+
+    # Fallback para outros dispositivos (desktop, etc)
+    return RedirectResponse(play_store_url)
+
+@app.get("/getAllUsers/", tags=["Usuários"], responses=STANDARD_RESPONSES)
 def conseguir_todos_os_usuarios_logado_com_o_email_normal_no_firebase():
     users = []
     page = auth.list_users()
     while page:
         for user in page.users:
             users.append({
                 "uid": user.uid,
-                "email": user.email or "",
-                "passwordHash": user.password_hash or "",
-                "passwordSalt": user.password_salt or "",
+                "email": user.email,
+                "passwordHash": user.password_hash,
+                "passwordSalt": user.password_salt,
+                "display_name": user.display_name,
                 "phone_number": user.phone_number or "",
-                "display_name": user.display_name or "",
+                "invite_url": user.invite_url,
                 "photo_url": user.photo_url or "",
             })
         page = page.get_next_page()
     return users
 
-@app.post("/add/user/", tags=["Usuários"])
+@app.post("/add/user/", tags=["Usuários"], responses=STANDARD_RESPONSES)
 async def criar_um_usuario_com_email_e_senha(email: str, password: str, display_name: str, phone_number: str | None = None, photo_url: str | None = None):
     user = auth.create_user(
         email=email,
@@ -99,97 +161,160 @@ async def criar_um_usuario_com_email_e_senha(email: str, password: str, display_
         password=password,
         display_name=display_name,
         photo_url=photo_url,
+        invite_url=generate_random_invite_url(),
         disabled=False)
     message = 'Criado um usuário com sucesso. UID: {0}'.format(user.uid)
     return {"message": message}
 
-@app.delete("/delete/user", tags=["Usuários"])
+@app.delete("/delete/user", tags=["Usuários"], responses=STANDARD_RESPONSES)
 async def deletar_um_usuario_com_o_uid(uid: str):
-    auth.delete_user(uid)
-    message = f'O usuário com o UID {uid} foi deletado com sucesso.'
-    return {"message": message}
+    if check_uid_exists(uid):
+        auth.delete_user(uid)
+        message = f'O usuário com o UID {uid} foi deletado com sucesso.'
+        return {"message": message}
+    else:
+        raise HTTPException(status_code=400, detail="Este usuário não existe no banco de dados")
 
-@app.get("/getAllAgendas", tags=["Agenda"])
+@app.get("/getAllAgendas", tags=["Agenda"], responses=STANDARD_RESPONSES)
 async def mostrar_todas_as_agendas_criadas():
     if agenda_ref.get() is None:
         message = f'Nenhuma agenda foi criada'
         return {"message": message}
     else:
         return agenda_ref.get()
 
-@app.post("/add/agenda/", tags=["Agenda"])
-async def criar_uma_agenda(nome_agenda: str):
-    uid = str(uuid.uuid4())
-    agenda_ref.update({
-        uid: {
-            'nome_agenda': nome_agenda
+@app.post("/add/agenda/", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def criar_uma_agenda(nome_agenda: str, uid_do_responsavel: str):
+    if check_uid_exists(uid_do_responsavel):
+        uid = str(uuid.uuid4())
+        agenda_ref.update({
+            uid: {
+                'nome_agenda': nome_agenda,
+                'uid_do_responsável': uid_do_responsavel
+            }
+        })
+        message = f'A agenda {nome_agenda} com o UID {uid} foi criada com sucesso'
+        return {"message": message}
+    else:
+        raise HTTPException(status_code=401, detail="Este usuário não existe no banco de dados")
+
+@app.post("/add/agenda/membro", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def adicionar_um_membro_na_agenda_já_criada(uid_da_agenda: str, uid_do_membro: str):
+    agenda_node = agenda_ref.child(uid_da_agenda)
+    agenda_data = agenda_node.get()
+    if not agenda_data:
+        raise HTTPException(status_code=404, detail=f"A agenda com o UID {uid_da_agenda} não existe")
+
+    if not check_uid_exists(uid_do_membro):
+        raise HTTPException(status_code=400, detail="Este usuário não existe no banco de dados")
+
+    user = auth.get_user(uid_do_membro)
+
+    membro_ref = agenda_node.child("membros")
+    membro_ref.update({
+        user.uid: {
+            'nome_do_usuário': user.display_name
         }
     })
-    message = f'A agenda {nome_agenda} com o UID {uid} foi criada com sucesso'
+    message = f'O membro {user.display} com o UID {user.uid} foi adicionado com sucesso'
     return {"message": message}
 
-@app.post("/add/agenda/materia", tags=["Agenda"])
-async def criar_uma_materia_na_agenda(uid_da_agenda: str, matéria: str):
-    matéria_criada = agenda_ref.child(uid_da_agenda).child("matérias")
+@app.post("/add/agenda/materia", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def criar_uma_materia_na_agenda_já_criada(uid_da_agenda: str, nome_da_matéria: str, nome_do_professor: str | None = None, horario_de_inicio_da_materia: str | None = None, horario_de_fim_da_materia: str | None = None):
+    agenda_node = agenda_ref.child(uid_da_agenda)
+    agenda_data = agenda_node.get()
+    if not agenda_data:
+        raise HTTPException(status_code=404, detail=f"A agenda com o UID {uid_da_agenda} não existe")
+
+    matérias_ref = agenda_node.child("matérias")
     uid = str(uuid.uuid4())
-    matéria_criada.update({
+    matérias_ref.update({
         uid: {
-            'nome_matéria': matéria
+            'nome_matéria': nome_da_matéria,
+            'professor': nome_do_professor,
+            'horario_de_início': horario_de_inicio_da_materia,
+            "horário_de_fim": horario_de_fim_da_materia
         }
     })
-    message = f'A matéria {matéria} com o UID {uid} foi criada com sucesso'
+    message = f'A matéria {nome_da_matéria} com o UID {uid} foi criada com sucesso'
     return {"message": message}
 
-@app.post("/add/agenda/tarefa", tags=["Agenda"])
-async def criar_uma_tarefa_na_agenda_criada(uid_da_agenda: str, nome_da_tarefa: str, timestamp: str):
-    uid = str(uuid.uuid4())
-    tarefa_criada = agenda_ref.child(uid_da_agenda).child("tarefas")
+@app.post("/add/agenda/tarefa", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def criar_uma_tarefa_na_agenda_já_criada(uid_da_agenda: str, nome_da_tarefa: str, timestamp: str):
+    agenda_node = agenda_ref.child(uid_da_agenda)
+    agenda_data = agenda_node.get()
+    if not agenda_data:
+        raise HTTPException(status_code=404, detail=f"A agenda com o UID {uid_da_agenda} não existe")
 
+    uid = str(uuid.uuid4())
+    tarefa_criada = agenda_node.child("tarefas")
     tarefa_criada.update({
         uid: {
             'nome_da_tarefa': nome_da_tarefa,
             'timestamp': timestamp_formatado(timestamp)
         }
     })
-
-    message = f'O tarefa com o UID {uid} foi criada com sucesso.'
+    message = f'A tarefa com o UID {uid} foi criada com sucesso.'
     return {"message": message}
 
-@app.post("/add/agenda/evento", tags=["Agenda"])
-async def criar_um_evento_na_agenda_criada(uid_da_agenda: str, nome_do_evento: str, timestamp: str):
-    uid = str(uuid.uuid4())
-    evento_criado = agenda_ref.child(uid_da_agenda).child("evento")
+@app.post("/add/agenda/evento", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def criar_um_evento_na_agenda_já_criada(uid_da_agenda: str, nome_do_evento: str, timestamp: str):
+    agenda_node = agenda_ref.child(uid_da_agenda)
+    agenda_data = agenda_node.get()
+    if not agenda_data:
+        raise HTTPException(status_code=404, detail=f"A agenda com o UID {uid_da_agenda} não existe")
 
+    uid = str(uuid.uuid4())
+    evento_criado = agenda_node.child("eventos")
     evento_criado.update({
         uid: {
             'nome_do_evento': nome_do_evento,
             'timestamp': timestamp_formatado(timestamp)
         }
     })
-
-    message = f'O tarefa com o UID {uid} foi criada com sucesso.'
+    message = f'O evento com o UID {uid} foi criado com sucesso.'
     return {"message": message}
 
-@app.delete("/delete/agenda/", tags=["Agenda"])
-async def deletar_uma_agenda_com_o_uid(uid: str):
-    agenda_ref.child(uid).delete()
-    message = f'O agenda com o UID {uid} foi deletada com sucesso.'
+@app.delete("/delete/agenda/", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def deletar_uma_agenda_com_o_uid(uid_da_agenda: str):
+    agenda_node = agenda_ref.child(uid_da_agenda)
+    agenda_data = agenda_node.get()
+    if not agenda_data:
+        raise HTTPException(status_code=404, detail=f"A agenda com o UID {uid_da_agenda} não existe")
+
+    agenda_node.delete()
+    message = f'A agenda com o UID {uid_da_agenda} foi deletada com sucesso.'
     return {"message": message}
 
-@app.delete("/delete/agenda/materia", tags=["Agenda"])
+@app.delete("/delete/agenda/materia", tags=["Agenda"], responses=STANDARD_RESPONSES)
 async def deletar_uma_materia_com_o_uid(uid_da_agenda: str, uid_da_materia: str):
-    agenda_ref.child(uid_da_agenda).child("matérias").child(uid_da_materia).delete()
+    matéria_node = agenda_ref.child(uid_da_agenda).child("matérias").child(uid_da_materia)
+    matéria_data = matéria_node.get()
+    if not matéria_data:
+        raise HTTPException(status_code=404, detail=f"A matéria com o UID {uid_da_materia} na agenda {uid_da_agenda} não existe")
+
+    matéria_node.delete()
     message = f'A matéria com o UID {uid_da_materia} foi deletada com sucesso.'
     return {"message": message}
 
-@app.delete("/delete/agenda/tarefa", tags=["Agenda"])
+@app.delete("/delete/agenda/tarefa", tags=["Agenda"], responses=STANDARD_RESPONSES)
 async def deletar_uma_tarefa_com_o_uid(uid_da_agenda: str, uid_da_tarefa: str):
-    agenda_ref.child(uid_da_agenda).child("tarefas").child(uid_da_tarefa).delete()
+    tarefa_node = agenda_ref.child(uid_da_agenda).child("tarefas").child(uid_da_tarefa)
+    tarefa_data = tarefa_node.get()
+    if not tarefa_data:
+        raise HTTPException(status_code=404, detail=f"A tarefa com o UID {uid_da_tarefa} na agenda {uid_da_agenda} não existe")
+
+    tarefa_node.delete()
     message = f'A tarefa com o UID {uid_da_tarefa} foi deletada com sucesso.'
     return {"message": message}
 
-@app.delete("/delete/agenda/evento", tags=["Agenda"])
+@app.delete("/delete/agenda/evento", tags=["Agenda"], responses=STANDARD_RESPONSES)
 async def deletar_um_evento_com_o_uid(uid_da_agenda: str, uid_do_evento: str):
-    agenda_ref.child(uid_da_agenda).child("evento").child(uid_do_evento).delete()
+    evento_node = agenda_ref.child(uid_da_agenda).child("eventos").child(uid_do_evento)
+    evento_data = evento_node.get()
+    if not evento_data:
+        raise HTTPException(status_code=404, detail=f"O evento com o UID {uid_do_evento} na agenda {uid_da_agenda} não existe")
+
+    evento_node.delete()
     message = f'O evento com o UID {uid_do_evento} foi deletado com sucesso.'
     return {"message": message}