Eddie/data wrapper (#543)

# Purpose
Closes #543.
Explain the purpose of the PR here if it doesn't match the linked issue.
Be sure to add a comment in the linked issue explaining the changes.

# New Changes
Explain new changes below in short bullet points.

Created data wrappers to used by endpoints in place of raw ORM calls to
the PostgreSQL database.

# Testing
Explain tests that you ran to verify code functionality.
- [ ] I have unit-tested this PR. Otherwise, explain why it cannot be
unit-tested.
- [ ] I have tested this PR on a board if the code will run on a board
(Only required for firmware developers).
- [ ] I have tested this PR by running the ARO website (Only required if
the code will impact the ARO website).
- [ ] I have tested this PR by running the MCC website (Only required if
the code will impact the MCC website).
- [ ] I have included screenshots of the tests performed below.

# Outstanding Changes
If there are non-critical changes (i.e. additional features) that can be
made to this feature in the future, indicate them here.

---------

Co-authored-by: Adityya Kaushal <52387864+Adityya-K@users.noreply.github.com>
Co-authored-by: Adityya Kaushal <adityyakaushal@gmail.com>

Author: Syzygicality

gs/backend/api/v1/mcc/endpoints/main_commands.py

@@ -1,18 +1,17 @@
-from fastapi import APIRouter, Depends
-from sqlmodel import Session, select
+from fastapi import APIRouter
 
 from gs.backend.api.v1.mcc.models.responses import MainCommandsResponse
-from gs.backend.data.database.engine import get_db_session
-from gs.backend.data.tables.main_tables import MainCommand
+from gs.backend.data.data_wrappers.mcc_wrappers.main_command_wrapper import get_all_main_commands
 
 main_commands_router = APIRouter(tags=["MCC", "Main Commands"])
 
 
 @main_commands_router.get("/")
-async def get_main_commands(db_session: Session = Depends(get_db_session)) -> MainCommandsResponse:
+async def get_main_commands() -> MainCommandsResponse:
     """
-    @brief Gets the main commands that are available for the MCC
+    Gets the main commands that are available for the MCC
+
+    :return: list of all commands
     """
-    main_commands_query = select(MainCommand)
-    items = list(db_session.exec(main_commands_query).all())
+    items = get_all_main_commands()
     return MainCommandsResponse(data=items)

gs/backend/data/data_wrappers/mcc_wrappers/commands_wrapper.py

@@ -0,0 +1,49 @@
+from typing import Any
+from uuid import UUID
+
+from sqlmodel import select
+
+from gs.backend.data.database.engine import get_db_session
+from gs.backend.data.tables.transactional_tables import Commands
+
+
+def get_all_commands() -> list[Commands]:
+    """
+    Get all data wrapper for Commands
+
+    :return: a list of all commands
+    """
+    with get_db_session() as session:
+        commands = list(session.exec(select(Commands)).all())
+        return commands
+
+
+def create_commands(command_data: dict[str, Any]) -> Commands:
+    """
+    Post data wrapper for Commands
+
+    :param command_data: the JSON object of the command to be created
+    :return: the newly created command
+    """
+    with get_db_session() as session:
+        command = Commands(**command_data)
+        session.add(command)
+        session.commit()
+        session.refresh(command)
+        return command
+
+
+def delete_commands_by_id(command_id: UUID) -> Commands:
+    """
+    Delete data wrapper for Commands
+
+    :param command_id: UUID of command to be deleted
+    :return: the deleted command
+    """
+    with get_db_session() as session:
+        command = session.get(Commands, command_id)
+        if not command:
+            raise ValueError("Command not found.")
+        session.delete(command)
+        session.commit()
+        return command

gs/backend/data/data_wrappers/mcc_wrappers/comms_session_wrapper.py

@@ -0,0 +1,49 @@
+from typing import Any
+from uuid import UUID
+
+from sqlmodel import select
+
+from gs.backend.data.database.engine import get_db_session
+from gs.backend.data.tables.transactional_tables import CommsSession
+
+
+def get_all_comms_sessions() -> list[CommsSession]:
+    """
+    Get all data wrapper for CommsSession
+
+    :return: a list of all sessions
+    """
+    with get_db_session() as session:
+        sessions = list(session.exec(select(CommsSession)).all())
+        return sessions
+
+
+def create_comms_session(session_data: dict[str, Any]) -> CommsSession:
+    """
+    Post data wrapper for CommsSession
+
+    :param session_data: the JSON object of the comms_session to be created
+    :return: the newly created comms_session
+    """
+    with get_db_session() as session:
+        comms_session = CommsSession(**session_data)
+        session.add(comms_session)
+        session.commit()
+        session.refresh(comms_session)
+        return comms_session
+
+
+def delete_telemetry_by_id(session_id: UUID) -> CommsSession:
+    """
+    Delete data wrapper for CommsSession
+
+    :param session_id: UUID of session to be deleted
+    :return: the deleted session
+    """
+    with get_db_session() as session:
+        comms_session = session.get(CommsSession, session_id)
+        if not comms_session:
+            raise ValueError("Comms session not found.")
+        session.delete(comms_session)
+        session.commit()
+        return comms_session

gs/backend/data/data_wrappers/mcc_wrappers/main_command_wrapper.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from sqlmodel import select
+
+from gs.backend.data.database.engine import get_db_session
+from gs.backend.data.tables.main_tables import MainCommand
+
+
+def get_all_main_commands() -> list[MainCommand]:
+    """
+    Get all data wrapper for MainCommand
+
+    :return: a list of all main_commands
+    """
+    with get_db_session() as session:
+        commands = list(session.exec(select(MainCommand)).all())
+        return commands
+
+
+def create_main_command(command_data: dict[str, Any]) -> MainCommand:
+    """
+    Post data wrapper for MainCommand
+
+    :param command_data: the JSON object of the main_command to be created
+    :return: the newly created main_command
+    """
+    with get_db_session() as session:
+        command = MainCommand(**command_data)
+        session.add(command)
+        session.commit()
+        session.refresh(command)
+        return command
+
+
+def delete_main_command_by_id(command_id: int) -> MainCommand:
+    """
+    Delete data wrapper for MainCommand
+
+    :param command_id: id of main_command to be deleted
+    :return: the deleted main_command
+    """
+    with get_db_session() as session:
+        command = session.get(MainCommand, command_id)
+        if not command:
+            raise ValueError("Main command not found.")
+        session.delete(command)
+        session.commit()
+        return command

gs/backend/data/data_wrappers/mcc_wrappers/main_telemetry_wrapper.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from sqlmodel import select
+
+from gs.backend.data.database.engine import get_db_session
+from gs.backend.data.tables.main_tables import MainTelemetry
+
+
+def get_all_main_telemetries() -> list[MainTelemetry]:
+    """
+    Get all data wrapper for MainTelemetry
+
+    :return: a list of all main_telemetries
+    """
+    with get_db_session() as session:
+        telemetries = list(session.exec(select(MainTelemetry)).all())
+        return telemetries
+
+
+def create_main_telemetry(telemetry_data: dict[str, Any]) -> MainTelemetry:
+    """
+    Post data wrapper for MainTelemetry
+
+    :param command_data: the JSON object of the main_telemetry to be created
+    :return: the newly created main_telemetry
+    """
+    with get_db_session() as session:
+        telemetry = MainTelemetry(**telemetry_data)
+        session.add(telemetry)
+        session.commit()
+        session.refresh(telemetry)
+        return telemetry
+
+
+def delete_main_telemetry_by_id(telemetry_id: int) -> MainTelemetry:
+    """
+    Delete data wrapper for MainTelemetry
+
+    :param command_id: id of main_telemetry to be deleted
+    :return: the deleted main_telemetry
+    """
+    with get_db_session() as session:
+        telemetry = session.get(MainTelemetry, telemetry_id)
+        if not telemetry:
+            raise ValueError("Main telemetry not found.")
+        session.delete(telemetry)
+        session.commit()
+        return telemetry

gs/backend/data/data_wrappers/mcc_wrappers/packet_commands_wrapper.py

@@ -0,0 +1,49 @@
+from typing import Any
+from uuid import UUID
+
+from sqlmodel import select
+
+from gs.backend.data.database.engine import get_db_session
+from gs.backend.data.tables.transactional_tables import PacketCommands
+
+
+def get_all_packet_commands() -> list[PacketCommands]:
+    """
+    Get all data wrapper for PacketCommands
+
+    :return: a list of all packet_commands
+    """
+    with get_db_session() as session:
+        commands = list(session.exec(select(PacketCommands)).all())
+        return commands
+
+
+def create_packet_command(command_data: dict[str, Any]) -> PacketCommands:
+    """
+    Post data wrapper for PacketCommands
+
+    :param command_data: the JSON object of the packet_command to be created
+    :return: the newly created packet_command
+    """
+    with get_db_session() as session:
+        command = PacketCommands(**command_data)
+        session.add(command)
+        session.commit()
+        session.refresh(command)
+        return command
+
+
+def delete_packet_command_by_id(command_id: UUID) -> PacketCommands:
+    """
+    Delete data wrapper for PacketCommands
+
+    :param command_id: UUID of packet_command to be deleted
+    :return: the deleted packet_command
+    """
+    with get_db_session() as session:
+        command = session.get(PacketCommands, command_id)
+        if not command:
+            raise ValueError("Packet command not found.")
+        session.delete(command)
+        session.commit()
+        return command

gs/backend/data/data_wrappers/mcc_wrappers/packet_telemetry_wrapper.py

@@ -0,0 +1,49 @@
+from typing import Any
+from uuid import UUID
+
+from sqlmodel import select
+
+from gs.backend.data.database.engine import get_db_session
+from gs.backend.data.tables.transactional_tables import PacketTelemetry
+
+
+def get_all_packet_telemetries() -> list[PacketTelemetry]:
+    """
+    Get all data wrapper for PacketTelemetry
+
+    :return: a list of all packet_telemetries
+    """
+    with get_db_session() as session:
+        telemetries = list(session.exec(select(PacketTelemetry)).all())
+        return telemetries
+
+
+def create_packet_telemetry(telemetry_data: dict[str, Any]) -> PacketTelemetry:
+    """
+    Post data wrapper for PacketTelemetry
+
+    :param command_data: the JSON object of the packet_telemetry to be created
+    :return: the newly created packet_telemetry
+    """
+    with get_db_session() as session:
+        telemetry = PacketTelemetry(**telemetry_data)
+        session.add(telemetry)
+        session.commit()
+        session.refresh(telemetry)
+        return telemetry
+
+
+def delete_packet_telemetry_by_id(telemetry_id: UUID) -> PacketTelemetry:
+    """
+    Delete data wrapper for PacketTelemetry
+
+    :param command_id: UUID of packet_telemetry to be deleted
+    :return: the deleted packet_telemetry
+    """
+    with get_db_session() as session:
+        telemetry = session.get(PacketTelemetry, telemetry_id)
+        if not telemetry:
+            raise ValueError("Packet telemetry not found.")
+        session.delete(telemetry)
+        session.commit()
+        return telemetry

gs/backend/data/data_wrappers/mcc_wrappers/packet_wrapper.py

@@ -0,0 +1,49 @@
+from typing import Any
+from uuid import UUID
+
+from sqlmodel import select
+
+from gs.backend.data.database.engine import get_db_session
+from gs.backend.data.tables.transactional_tables import Packet
+
+
+def get_all_packets() -> list[Packet]:
+    """
+    Get all data wrapper for Packet
+
+    :return: a list of all packets
+    """
+    with get_db_session() as session:
+        packets = list(session.exec(select(Packet)).all())
+        return packets
+
+
+def create_packet(packet_data: dict[str, Any]) -> Packet:
+    """
+    Post data wrapper for Packet
+
+    :param packet_data: the JSON object of the packet to be created
+    :return: the newly created packet
+    """
+    with get_db_session() as session:
+        packet = Packet(**packet_data)
+        session.add(packet)
+        session.commit()
+        session.refresh(packet)
+        return packet
+
+
+def delete_packet_by_id(packet_id: UUID) -> Packet:
+    """
+    Delete data wrapper for Packet
+
+    :param packet_id: UUID of packet to be deleted
+    :return: the deleted packet
+    """
+    with get_db_session() as session:
+        packet = session.get(Packet, packet_id)
+        if not packet:
+            raise ValueError("Packet not found.")
+        session.delete(packet)
+        session.commit()
+        return packet