Kai ZHang GS-Onboarding

backend/api/endpoints/command.py

@@ -1,5 +1,6 @@
 from fastapi import APIRouter, Depends
 from sqlmodel import Session, select
+from fastapi import HTTPException
 
 from backend.api.models.request_model import CommandRequest
 from backend.api.models.response_model import CommandListResponse, CommandSingleResponse
@@ -23,23 +24,36 @@ def get_commands(db: Session = Depends(get_db)):
 
 
 @command_router.post("/", response_model=CommandSingleResponse)
-def create_command(payload: CommandRequest):
+def create_command(payload: CommandRequest, db: Session = Depends(get_db)):
     """
     Creates an item with the given payload in the database and returns this payload after pulling it from the database 
 
     :param payload: The data used to create an item
     :return: returns a json object with field of "data" under which there is the payload now pulled from the database 
     """
-    # TODO:(Member) Implement this endpoint
-
-
+    command = Command(command_type = payload.command_type, params = payload.params)
+    db.add(command)
+    db.commit()
+    query = select(Command).where(Command.params == payload.params)
+    command_request = db.exec(query).first()
+    return {"data": command_request}
 
 @command_router.delete("/{id}", response_model=CommandListResponse)
-def delete_command(id: int):
+def delete_command(id: int, db: Session = Depends(get_db)):
     """
     Deletes the item with the given id if it exists. Otherwise raises a 404 error.
 
     :param id: The id of the item to delete
     :return: returns the list of commands after deleting the item
     """
-    # TODO:(Member) Implement this endpoint
+    query = select(Command).where(Command.id == id)
+    item_to_delete = db.exec(query).first()
+    if item_to_delete == None: raise HTTPException(status_code=404, detail="Command with the following ID not found")
+    else:
+        db.delete(item_to_delete)
+        db.commit()
+    query = select(Command)
+    items = db.exec(query).all()
+    return {"data": items}
+
+

backend/api/middlewares/logger_middleware.py

@@ -2,7 +2,10 @@
 from typing import Any
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
-
+from backend.utils.logging import logger_setup, logger_setup_file, logger_close
+from loguru import logger
+import time
+import json
 
 class LoggerMiddleware(BaseHTTPMiddleware):
     async def dispatch(
@@ -17,6 +20,21 @@ async def dispatch(
         :param call_next: Endpoint or next middleware to be called (if any, this is the next middleware in the chain of middlewares, it is supplied by FastAPI)
         :return: Response from endpoint
         """
-        # TODO:(Member) Finish implementing this method
+
+        command_request_body = await request.body()
+        try: command_request_body = json.loads(command_request_body.decode("utf-8"))
+        except json.JSONDecodeError: command_request_body = {}
+        command_request_params = command_request_body.get("params")
+
+        start_time = time.perf_counter()
         response = await call_next(request)
+        end_time = time.perf_counter()
+        execution_time = end_time - start_time
+
+        logger_setup()
+        logger_setup_file()
+
+        logger.info("Received a request with paramters: {} \n Duration of execution: {}", command_request_params, execution_time)
+        await logger_close()
         return response
+

backend/data/data_models.py

@@ -32,7 +32,12 @@ def validate_params_format(self):
         In either of these cases return self. Otherwise raise a ValueError.
         The format of the comma seperated values is "data1,data2" so no spaces between data and the commas.
         """
-        # TODO: (Member) Implement this method
+        num_values = 0
+        if self.params != None:
+            if self.format == None: raise ValueError
+            if len(self.format.split(",")) != len(self.params.split(",")): raise ValueError
+        else:
+            if self.format != None: raise ValueError
         return self
 
 
@@ -41,7 +46,6 @@ class Command(BaseSQLModel, table=True):
     An instance of a MainCommand.
     This table holds the data related to actual commands sent from the ground station up to the OBC.
     """
-
     id: int | None = Field(
         default=None, primary_key=True
     )  # NOTE: Must be None for autoincrement

frontend/src/display/command_api.ts

@@ -1,6 +1,6 @@
 import axios from "axios";
 import { CommandListResponse } from "../data/response";
-import { API_URL } from "../environment";
+import { API_URL } from "../environment"; 
 
 export const getCommands = async (): Promise<CommandListResponse> => {
   try {
@@ -12,11 +12,13 @@ export const getCommands = async (): Promise<CommandListResponse> => {
   }
 }
 
-/**
- * TODO: (Member) Create a deleteCommand API function based on the following specs. You should be using axios to make the API call
- *
- * Deletes the command with the given id on the backend and returns the list of commands after its deletion.
- *
- * @param id: command to delete
- * @returns Promise<CommandListResponse>: list of commands after the command with the given id was deleted
- */
+export const deleteCommand = async (id: number): Promise<CommandListResponse> => {
+  try {
+    await axios.delete<CommandListResponse>(`${API_URL}/commands/${id}`)
+    const { data } = await axios.get<CommandListResponse>(`${API_URL}/commands/${id}`)
+    return data;
+  } catch (error) {
+    console.error(`Error deleting command with ID ${id}): ${error}`);
+    throw error
+  }
+}

frontend/src/display/table.tsx

@@ -1,5 +1,6 @@
 import { CommandResponse } from "../data/response"
 import CommandRow from "./row"
+import { deleteCommand } from "./command_api.ts"
 
 interface CommandTableProp {
   commands: CommandResponse[],
@@ -13,7 +14,6 @@ const CommandTable = ({
 
   const handleDelete = (id: number) => {
     return async () => {
-      // TODO: (Member) You will need to create a function in `command_api.ts` so you can delete a command.
       const data = await deleteCommand(id)
       setCommands(data.data)
     }

frontend/src/input/command_input.tsx

@@ -1,6 +1,11 @@
-import { useState } from "react";
-import { CommandResponse, MainCommandResponse } from "../data/response"
+import { useState, useEffect } from "react";
+import { CommandResponse, MainCommandResponse, CommandListResponse} from "../data/response"
 import "./command_input.css"
+import { MainCommandListResponse } from "../data/response";
+import axios from "axios";
+import { API_URL } from "../environment"; 
+import { getMainCommands } from "./input_api"
+import { CommandRequest } from "../data/request";
 
 interface CommandInputProp {
   setCommands: React.Dispatch<React.SetStateAction<CommandResponse[]>>
@@ -9,9 +14,15 @@ interface CommandInputProp {
 const CommandInput = ({ setCommands }: CommandInputProp) => {
   const [selectedCommand, setSelectedCommand] = useState<MainCommandResponse | null>(null);
   const [parameters, setParameters] = useState<{ [key: string]: string }>({});
-  // TODO: (Member) Setup anymore states if necessary
+  const [mainCommands, setMainCommands] = useState<MainCommandListResponse | null>(null);
 
-  // TODO: (Member) Fetch MainCommands in a useEffect
+  useEffect(() => {
+    const fetchCommands = async() => {
+      const data = await getMainCommands();
+      setMainCommands(data);
+    };
+    fetchCommands();
+  }, []);
 
   const handleParameterChange = (param: string, value: string): void => {
     setParameters((prev) => ({
@@ -20,21 +31,46 @@ const CommandInput = ({ setCommands }: CommandInputProp) => {
     }));
   }
 
+  const handleChange = async (e: React.ChangeEvent<HTMLSelectElement>) => {
+    if (mainCommands == null) return;
+    const selectedID = e.target.value;
+    const command = mainCommands.data.find(c => c.id === Number(selectedID));
+    setSelectedCommand(command ?? null)
+  } 
+
   const handleSubmit = async (e: React.FormEvent) => {
-    // TODO:(Member) Submit to your post endpoint 
+    e.preventDefault();
+    if (!selectedCommand) {
+      console.error(`Exited early`);
+      return;
+    }
+    const payload: CommandRequest = {
+      command_type: selectedCommand.id,
+      params: selectedCommand.params
+    }
+    axios.post(`${API_URL}/commands/`, payload);
   }
-
-  return (
+ 
+  if (mainCommands) return (
     <>
       <form onSubmit={handleSubmit}>
         <div className="spreader">
           <div>
             <label>Command Type: </label>
-            <select>{/* TODO: (Member) Display the list of commands based on the get commands request.
+
+            <select value={selectedCommand ? selectedCommand.id : ""} onChange={handleChange}
+
+            >{/* TODO: (Member) Display the list of commands based on the get commands request.
                         It should update the `selectedCommand` field when selecting one.*/}
-              <option value={"1"}>Command 1</option>
+              {/* <option value={"1"}>Command 1</option>
               <option value={"2"}>Command 2</option>
-              <option value={"3"}>Command 3</option>
+              <option value={"3"}>Command 3</option> */}
+
+              {mainCommands?.data.map(command => (
+                <option value={command.id}>
+                  {command.name}
+                </option>
+              ))}
             </select>
           </div>
           {selectedCommand?.params?.split(",").map((param) => (