Add Public Waiting List Tab

Frontend/src/api/registration/get/get_registrations.ts

@@ -12,6 +12,28 @@ const { GET } = createClient<paths>({
   baseUrl: process.env.API_URL.slice(0, -7),
 })
 
+async function addUserInfo(
+  registrations:
+    | components['schemas']['registration'][]
+    | components['schemas']['registrationAdmin'][]
+): Promise<
+  | components['schemas']['registration'][]
+  | components['schemas']['registrationAdmin'][]
+> {
+  if (registrations.length > 0) {
+    const userInfos = await getCompetitorsInfo(
+      registrations.map((d) => d.user_id)
+    )
+    return registrations.map((registration) => ({
+      ...registration,
+      user: userInfos.users.find(
+        (user) => user.id === Number(registration.user_id)
+      ),
+    }))
+  }
+  return []
+}
+
 export async function getConfirmedRegistrations(
   competitionID: string
 ): Promise<components['schemas']['registration'][]> {
@@ -25,16 +47,7 @@ export async function getConfirmedRegistrations(
   if (!response.ok) {
     throw new BackendError(500, response.status)
   }
-  if (data!.length > 0) {
-    const userInfos = await getCompetitorsInfo(data!.map((d) => d.user_id))
-    return data!.map((registration) => ({
-      ...registration,
-      user: userInfos.users.find(
-        (user) => user.id === Number(registration.user_id)
-      ),
-    }))
-  }
-  return []
+  return addUserInfo(data!)
 }
 
 export async function getAllRegistrations(
@@ -55,13 +68,9 @@ export async function getAllRegistrations(
     }
     throw new BackendError(error.error, response.status)
   }
-  const userInfos = await getCompetitorsInfo(data!.map((d) => d.user_id))
-  return data!.map((registration) => ({
-    ...registration,
-    user: userInfos.users.find(
-      (user) => user.id === Number(registration.user_id)
-    ),
-  }))
+  return (await addUserInfo(
+    data!
+  )) as components['schemas']['registrationAdmin'][]
 }
 
 export async function getSingleRegistration(
@@ -74,3 +83,19 @@ export async function getSingleRegistration(
     { needsAuthentication: true }
   ) as Promise<{ registration: components['schemas']['registrationAdmin'] }>
 }
+
+export async function getWaitingCompetitors(
+  competitionId: string
+): Promise<components['schemas']['registrationAdmin'][]> {
+  const registrations = (await backendFetch(
+    `/registrations/${competitionId}/waiting`,
+    'GET',
+    {
+      needsAuthentication: false,
+    }
+  )) as components['schemas']['registrationAdmin'][]
+
+  return (await addUserInfo(
+    registrations
+  )) as components['schemas']['registrationAdmin'][]
+}

Frontend/src/api/schema.d.ts

@@ -3,195 +3,196 @@
  * Do not make direct changes to the file.
  */
 
-
 export interface paths {
-  "/api/v1/registrations/{competition_id}": {
+  '/api/v1/registrations/{competition_id}': {
     /** Public: list registrations for a given competition_id */
     get: {
       parameters: {
         path: {
-          competition_id: string;
-        };
-      };
+          competition_id: string
+        }
+      }
       responses: {
         /** @description  -> PASSING comp service down but registrations exist */
         200: {
           content: {
-            "application/json": components["schemas"]["registration"][];
-          };
-        };
-      };
-    };
-  };
-  "/api/v1/registrations/{competition_id}/admin": {
+            'application/json': components['schemas']['registration'][]
+          }
+        }
+      }
+    }
+  }
+  '/api/v1/registrations/{competition_id}/admin': {
     /** Public: list registrations for a given competition_id */
     get: {
       parameters: {
         path: {
-          competition_id: string;
-        };
-      };
+          competition_id: string
+        }
+      }
       responses: {
         /** @description  -> PASSING organizer has access to comp 2 */
         200: {
           content: {
-            "application/json": components["schemas"]["registrationAdmin"][];
-          };
-        };
+            'application/json': components['schemas']['registrationAdmin'][]
+          }
+        }
         /** @description  -> PASSING organizer cannot access registrations for comps they arent organizing - multi comp auth */
         401: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
-      };
-    };
-  };
-  "/api/v1/register": {
+            'application/json': components['schemas']['error_response']
+          }
+        }
+      }
+    }
+  }
+  '/api/v1/register': {
     /** Add an attendee registration */
     post: {
       requestBody: {
         content: {
-          "application/json": components["schemas"]["submitRegistrationBody"];
-        };
-      };
+          'application/json': components['schemas']['submitRegistrationBody']
+        }
+      }
       responses: {
         /** @description -> PASSING competitor submits basic registration */
         202: {
           content: {
-            "application/json": components["schemas"]["success_response"];
-          };
-        };
+            'application/json': components['schemas']['success_response']
+          }
+        }
         /** @description  -> PASSING empty payload provided */
         400: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
+            'application/json': components['schemas']['error_response']
+          }
+        }
         /** @description  -> PASSING user impersonation (no admin permission, JWT token user_id does not match registration user_id) */
         401: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
+            'application/json': components['schemas']['error_response']
+          }
+        }
         /** @description  -> PASSING user cant register while registration is closed */
         403: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
+            'application/json': components['schemas']['error_response']
+          }
+        }
         /** @description  -> PASSING competition does not exist */
         404: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
+            'application/json': components['schemas']['error_response']
+          }
+        }
         /** @description PASSING user registration exceeds guest limit */
         422: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
-      };
-    };
+            'application/json': components['schemas']['error_response']
+          }
+        }
+      }
+    }
     /** update or cancel an attendee registration */
     patch: {
       requestBody: {
         content: {
-          "application/json": components["schemas"]["updateRegistrationBody"];
-        };
-      };
+          'application/json': components['schemas']['updateRegistrationBody']
+        }
+      }
       responses: {
         /** @description PASSING user changes comment */
         200: {
           content: {
-            "application/json": {
-              status?: string;
-              registration?: components["schemas"]["registrationAdmin"];
-            };
-          };
-        };
+            'application/json': {
+              status?: string
+              registration?: components['schemas']['registrationAdmin']
+            }
+          }
+        }
         /** @description PASSING user requests invalid status change to their own reg */
         401: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
+            'application/json': components['schemas']['error_response']
+          }
+        }
         /** @description PASSING user changes events / other stuff past deadline */
         403: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
+            'application/json': components['schemas']['error_response']
+          }
+        }
         /** @description PASSING user does not include required comment */
         422: {
           content: {
-            "application/json": components["schemas"]["error_response"];
-          };
-        };
-      };
-    };
-  };
+            'application/json': components['schemas']['error_response']
+          }
+        }
+      }
+    }
+  }
 }
 
-export type webhooks = Record<string, never>;
+export type webhooks = Record<string, never>
 
 export interface components {
   schemas: {
     error_response: {
-      error: number;
-    };
+      error: number
+    }
     success_response: {
-      status: string;
-      message: string;
-    };
+      status: string
+      message: string
+    }
     registration: {
-      user_id: string;
+      user_id: string
       competing: {
-        event_ids: EventId[];
-      };
-    };
+        event_ids: EventId[]
+      }
+    }
     registrationAdmin: {
-      user_id: string;
+      user_id: string
       competing: {
-        event_ids: EventId[];
-        registered_on: string;
-        registration_status: string;
-        comment?: string | null;
-        admin_comment?: string | null;
-      };
-      guests?: number | null;
-    };
+        event_ids: EventId[]
+        registered_on: string
+        registration_status: string
+        comment?: string | null
+        admin_comment?: string | null
+        waiting_list_position?: number | null
+      }
+      guests?: number | null
+    }
     submitRegistrationBody: {
-      user_id: string;
-      competition_id: string;
+      user_id: string
+      competition_id: string
       competing: {
-        event_ids?: EventId[];
-        comment?: string;
-        guests?: number;
-      };
-    };
+        event_ids?: EventId[]
+        comment?: string
+        guests?: number
+      }
+    }
     updateRegistrationBody: {
-      user_id: string;
-      competition_id: string;
+      user_id: string
+      competition_id: string
       competing?: {
-        event_ids?: EventId[];
-        status?: string;
-        comment?: string;
-        admin_comment?: string;
-      };
-      guests?: number;
-    };
-  };
-  responses: never;
-  parameters: never;
-  requestBodies: never;
-  headers: never;
-  pathItems: never;
+        event_ids?: EventId[]
+        status?: string
+        comment?: string
+        admin_comment?: string
+        waiting_list_position?: number
+      }
+      guests?: number
+    }
+  }
+  responses: never
+  parameters: never
+  requestBodies: never
+  headers: never
+  pathItems: never
 }
 
-export type $defs = Record<string, never>;
+export type $defs = Record<string, never>
 
-export type external = Record<string, never>;
+export type external = Record<string, never>
 
-export type operations = Record<string, never>;
+export type operations = Record<string, never>