Merge pull request #13 from marshfellow42/main

Terminar os issues que eu tinha na Sprint dessa semana

Author: marshfellow42

.env.example

@@ -13,3 +13,6 @@ CLIENT_CERT_URL=https://www.googleapis.com/robot/v1/metadata/x509/your-service-a
 
 # Firebase Realtime Database URL
 DATABASE_URL=https://your-project-id-default-rtdb.firebaseio.com/
+
+# API key secret word
+SECRET_API_WORD = "your_secret_word"

api/main.py

@@ -1,15 +1,24 @@
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Depends, Query
 from fastapi.responses import RedirectResponse
-import firebase_admin
+
 from firebase_admin import credentials, db, auth
+import firebase_admin
+
 import phonenumbers
 from phonenumbers import PhoneNumberFormat
-import uuid
+
+from pydantic import BaseModel
+from typing import Optional
+
 from datetime import datetime
 import os
-from dotenv import load_dotenv
 import random
 import string
+import uuid
+import hashlib
+import base64
+
+from dotenv import load_dotenv
 
 load_dotenv()
 
@@ -61,10 +70,20 @@ def check_uid_exists(uid: str):
         print(f"⚠️ Error: {e}")
         return False
 
-def generate_random_invite_url(length: int = 12) -> str:
+def generate_random_invite_key(length: int = 12) -> str:
     chars = string.ascii_letters + string.digits  # A-Z, a-z, 0-9
     return ''.join(random.choices(chars, k=length))
 
+word = os.getenv("SECRET_API_WORD")
+hash_bytes = hashlib.sha256(word.encode()).digest()
+API_KEY = base64.urlsafe_b64encode(hash_bytes).rstrip(b'=').decode()
+API_KEY_NAME = "api_key"
+
+def get_api_key(api_key: str = Query(default=None, alias=API_KEY_NAME)):
+    if api_key == API_KEY:
+        return api_key
+    raise HTTPException(status_code=403, detail="Chave API não autorizada")
+
 STANDARD_RESPONSES = {
     400: {"description": "Bad Request"},
     401: {"description": "Unauthorized"},
@@ -84,7 +103,11 @@ def generate_random_invite_url(length: int = 12) -> str:
     },
 ]
 
-app = FastAPI(openapi_tags=tags_metadata)
+app = FastAPI(title='Cosmos API', openapi_tags=tags_metadata)
+
+class AgendaPatch(BaseModel):
+    nome_agenda: Optional[str] = None
+    uid_do_responsável: Optional[str] = None
 
 @app.get("/")
 def read_root():
@@ -94,20 +117,20 @@ def read_root():
 def testar_o_firebase():
     try:
         if ref.get():
-            message = "Conectado com successo ao Firebase"
-            return {"message": message}
+            return {"message": "Conectado com successo ao Firebase"}
     except Exception as e:
         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)
+@app.get("/invite/{chave_de_convite_da_agenda}", responses=STANDARD_RESPONSES)
+def mandar_um_convite_para_entrar_na_turma_tipo_o_whatsapp(chave_de_convite_da_agenda: str, request: Request):
+    agenda_node = agenda_ref.order_by_child('chave_de_convite').equal_to(chave_de_convite_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")
+        raise HTTPException(status_code=404, detail=f"Essa agenda não existe")
+
+    for key, val in agenda_data.items():
+        return (f"UID da Agenda: {key}, Data: {val}")
 
     # Detecta o dispositivo
     user_agent = request.headers.get("user-agent", "").lower()
@@ -134,7 +157,7 @@ def mandar_um_convite_para_entrar_na_turma_tipo_o_whatsapp(uid_da_agenda: str, r
     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():
+def conseguir_todos_os_usuarios_logado_com_o_email_normal_no_firebase(api_key: str = Depends(get_api_key)):
     users = []
     page = auth.list_users()
     while page:
@@ -146,60 +169,57 @@ def conseguir_todos_os_usuarios_logado_com_o_email_normal_no_firebase():
                 "passwordSalt": user.password_salt,
                 "display_name": user.display_name,
                 "phone_number": user.phone_number or "",
-                "invite_url": user.invite_url,
-                "photo_url": user.photo_url or "",
+                "photo_url": user.photo_url or ""
             })
         page = page.get_next_page()
     return users
 
 @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):
+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, api_key: str = Depends(get_api_key)):
     user = auth.create_user(
         email=email,
         email_verified=False,
         phone_number=to_e164_br(phone_number),
         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}
+
+    return {"message": 'Criado um usuário com sucesso. UID: {0}'.format(user.uid)}
 
 @app.delete("/delete/user", tags=["Usuários"], responses=STANDARD_RESPONSES)
-async def deletar_um_usuario_com_o_uid(uid: str):
+async def deletar_um_usuario_com_o_uid(uid: str, api_key: str = Depends(get_api_key)):
     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}
+        return {"message": f'O usuário com o UID {uid} foi deletado com sucesso.'}
     else:
         raise HTTPException(status_code=400, detail="Este usuário não existe no banco de dados")
 
 @app.get("/getAllAgendas", tags=["Agenda"], responses=STANDARD_RESPONSES)
-async def mostrar_todas_as_agendas_criadas():
+async def mostrar_todas_as_agendas_criadas(api_key: str = Depends(get_api_key)):
     if agenda_ref.get() is None:
-        message = f'Nenhuma agenda foi criada'
-        return {"message": message}
+        return {"message": 'Nenhuma agenda foi criada'}
     else:
         return agenda_ref.get()
 
 @app.post("/add/agenda/", tags=["Agenda"], responses=STANDARD_RESPONSES)
-async def criar_uma_agenda(nome_agenda: str, uid_do_responsavel: str):
+async def criar_uma_agenda(nome_agenda: str, uid_do_responsavel: str, api_key: str = Depends(get_api_key)):
     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
+                'uid_do_responsável': uid_do_responsavel,
+                'chave_de_convite': generate_random_invite_key()
             }
         })
-        message = f'A agenda {nome_agenda} com o UID {uid} foi criada com sucesso'
-        return {"message": message}
+
+        return {"message": f'A agenda {nome_agenda} com o UID {uid} foi criada com sucesso'}
     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):
+async def adicionar_um_membro_na_agenda_já_criada(uid_da_agenda: str, uid_do_membro: str, api_key: str = Depends(get_api_key)):
     agenda_node = agenda_ref.child(uid_da_agenda)
     agenda_data = agenda_node.get()
     if not agenda_data:
@@ -216,11 +236,11 @@ async def adicionar_um_membro_na_agenda_já_criada(uid_da_agenda: str, uid_do_me
             'nome_do_usuário': user.display_name
         }
     })
-    message = f'O membro {user.display} com o UID {user.uid} foi adicionado com sucesso'
-    return {"message": message}
+
+    return {"message": f'O membro {user.display} com o UID {user.uid} foi adicionado com sucesso'}
 
 @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):
+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, api_key: str = Depends(get_api_key)):
     agenda_node = agenda_ref.child(uid_da_agenda)
     agenda_data = agenda_node.get()
     if not agenda_data:
@@ -236,11 +256,11 @@ async def criar_uma_materia_na_agenda_já_criada(uid_da_agenda: str, nome_da_mat
             "horário_de_fim": horario_de_fim_da_materia
         }
     })
-    message = f'A matéria {nome_da_matéria} com o UID {uid} foi criada com sucesso'
-    return {"message": message}
+
+    return {"message": f'A matéria {nome_da_matéria} com o UID {uid} foi criada com sucesso'}
 
 @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):
+async def criar_uma_tarefa_na_agenda_já_criada(uid_da_agenda: str, nome_da_tarefa: str, timestamp: str, api_key: str = Depends(get_api_key)):
     agenda_node = agenda_ref.child(uid_da_agenda)
     agenda_data = agenda_node.get()
     if not agenda_data:
@@ -254,11 +274,11 @@ async def criar_uma_tarefa_na_agenda_já_criada(uid_da_agenda: str, nome_da_tare
             'timestamp': timestamp_formatado(timestamp)
         }
     })
-    message = f'A tarefa com o UID {uid} foi criada com sucesso.'
-    return {"message": message}
+
+    return {"message": f'A tarefa com o UID {uid} foi criada com sucesso.'}
 
 @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):
+async def criar_um_evento_na_agenda_já_criada(uid_da_agenda: str, nome_do_evento: str, timestamp: str, api_key: str = Depends(get_api_key)):
     agenda_node = agenda_ref.child(uid_da_agenda)
     agenda_data = agenda_node.get()
     if not agenda_data:
@@ -272,49 +292,137 @@ async def criar_um_evento_na_agenda_já_criada(uid_da_agenda: str, nome_do_event
             'timestamp': timestamp_formatado(timestamp)
         }
     })
-    message = f'O evento com o UID {uid} foi criado com sucesso.'
-    return {"message": message}
+
+    return {"message": f'O evento com o UID {uid} foi criado com sucesso.'}
 
 @app.delete("/delete/agenda/", tags=["Agenda"], responses=STANDARD_RESPONSES)
-async def deletar_uma_agenda_com_o_uid(uid_da_agenda: str):
+async def deletar_uma_agenda_com_o_uid(uid_da_agenda: str, api_key: str = Depends(get_api_key)):
     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}
+
+    return {"message": f'A agenda com o UID {uid_da_agenda} foi deletada com sucesso.'}
 
 @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):
+async def deletar_uma_materia_com_o_uid(uid_da_agenda: str, uid_da_materia: str, api_key: str = Depends(get_api_key)):
     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}
+
+    return {"message": f'A matéria com o UID {uid_da_materia} foi deletada com sucesso.'}
 
 @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):
+async def deletar_uma_tarefa_com_o_uid(uid_da_agenda: str, uid_da_tarefa: str, api_key: str = Depends(get_api_key)):
     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}
+
+    return {"message": f'A tarefa com o UID {uid_da_tarefa} foi deletada com sucesso.'}
 
 @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):
+async def deletar_um_evento_com_o_uid(uid_da_agenda: str, uid_do_evento: str, api_key: str = Depends(get_api_key)):
     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}
+
+    return {"message": f'O evento com o UID {uid_do_evento} foi deletado com sucesso.'}
+
+@app.patch("/update/agenda", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def atualizar_os_dados_da_agenda(uid_da_agenda: str = Query(...), nome_agenda: str = Query(None), uid_do_responsável: str = Query(None), api_key: str = Depends(get_api_key)):
+    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")
+
+    update_data = {}
+    if nome_agenda is not None:
+        update_data["nome_agenda"] = nome_agenda
+    if uid_do_responsável is not None:
+        update_data["uid_do_responsável"] = uid_do_responsável
+
+    if not update_data:
+        raise HTTPException(status_code=400, detail="Nenhum dado fornecido para atualização")
+
+    agenda_node.update(update_data)
+
+    return {"message": "Agenda atualizada com sucesso", "dados": update_data}
+
+@app.patch("/update/agenda/materia", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def atualizar_os_dados_da_agenda(uid_da_agenda: str = Query(...), uid_da_materia: str = Query(...), nome_da_matéria: str = Query(None), nome_do_professor: str = Query(None), horario_de_inicio_da_materia: str = Query(None), horario_de_fim_da_materia: str = Query(None), api_key: str = Depends(get_api_key)):
+    agenda_node = agenda_ref.child(uid_da_agenda).child("matérias").child(uid_da_materia)
+    agenda_data = agenda_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")
+
+    update_data = {}
+    if nome_da_matéria is not None:
+        update_data["nome_matéria"] = nome_da_matéria
+    if nome_do_professor is not None:
+        update_data["professor"] = nome_do_professor
+    if horario_de_inicio_da_materia is not None:
+        update_data["horario_de_início"] = horario_de_inicio_da_materia
+    if horario_de_fim_da_materia is not None:
+        update_data["horario_de_fim"] = horario_de_fim_da_materia
+
+    if not update_data:
+        raise HTTPException(status_code=400, detail="Nenhum dado fornecido para atualização")
+
+    agenda_node.update(update_data)
+
+    return {"message": "Agenda atualizada com sucesso", "dados": update_data}
+
+@app.patch("/update/agenda/tarefa", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def atualizar_os_dados_da_agenda(uid_da_agenda: str = Query(...), uid_da_tarefa: str = Query(...), nome_da_tarefa: str = Query(None), timestamp: str = Query(None), api_key: str = Depends(get_api_key)):
+    agenda_node = agenda_ref.child(uid_da_agenda).child("tarefas").child(uid_da_tarefa)
+    agenda_data = agenda_node.get()
+    if not matéria_data:
+        raise HTTPException(status_code=404, detail=f"A tarefa com o UID {uid_da_tarefa} na agenda {uid_da_agenda} não existe")
+
+    timestamp_definido = timestamp_formatado(timestamp)
+
+    update_data = {}
+    if nome_da_tarefa is not None:
+        update_data["nome_da_tarefa"] = nome_da_tarefa
+    if timestamp_definido is not None:
+        update_data["timestamp"] = timestamp_definido
+
+    if not update_data:
+        raise HTTPException(status_code=400, detail="Nenhum dado fornecido para atualização")
+
+    agenda_node.update(update_data)
+
+    return {"message": "Agenda atualizada com sucesso", "dados": update_data}
+
+@app.patch("/update/agenda/evento", tags=["Agenda"], responses=STANDARD_RESPONSES)
+async def atualizar_os_dados_da_agenda(uid_da_agenda: str = Query(...), uid_do_evento: str = Query(...), nome_do_evento: str = Query(None), timestamp: str = Query(None), api_key: str = Depends(get_api_key)):
+    agenda_node = agenda_ref.child(uid_da_agenda).child("eventos").child(uid_do_evento)
+    agenda_data = agenda_node.get()
+    if not matéria_data:
+        raise HTTPException(status_code=404, detail=f"O evento com o UID {uid_do_evento} na agenda {uid_da_agenda} não existe")
+
+    timestamp_definido = timestamp_formatado(timestamp)
+
+    update_data = {}
+    if nome_da_tarefa is not None:
+        update_data["nome_do_evento"] = nome_do_evento
+    if timestamp_definido is not None:
+        update_data["timestamp"] = timestamp_definido
+
+    if not update_data:
+        raise HTTPException(status_code=400, detail="Nenhum dado fornecido para atualização")
+
+    agenda_node.update(update_data)
+
+    return {"message": "Agenda atualizada com sucesso", "dados": update_data}