Adds solver specific settings

src/api/ToolboxAPI.ts

@@ -1,6 +1,7 @@
 import { getInvalidProblemDto, ProblemDto } from "./data-model/ProblemDto";
 import { ProblemSolverInfo } from "./data-model/ProblemSolverInfo";
 import { ProblemState } from "./data-model/ProblemState";
+import { SolverSetting } from "./data-model/SolverSettings";
 import { SubRoutineDefinitionDto } from "./data-model/SubRoutineDefinitionDto";
 
 /**
@@ -61,11 +62,14 @@ export async function postProblem<T>(
 export async function patchProblem<T>(
   problemTypeId: string,
   problemId: string,
-  updateParameters: { input?: any; solverId?: string; state?: ProblemState }
+  updateParameters: {
+    input?: any;
+    solverId?: string;
+    state?: ProblemState;
+    solverSettings?: SolverSetting[];
+  }
 ): Promise<ProblemDto<T>> {
-  let url = `${baseUrl()}/problems/${problemTypeId}/${problemId}`;
-  console.log(url);
-  return fetch(url, {
+  return fetch(`${baseUrl()}/problems/${problemTypeId}/${problemId}`, {
     method: "PATCH",
     headers: {
       "Content-Type": "application/json",
@@ -105,9 +109,7 @@ export async function fetchSubRoutines(
   solverId: string
 ): Promise<SubRoutineDefinitionDto[]> {
   return fetch(
-    `${baseUrl()}/sub-routines/${problemTypeId}?${new URLSearchParams({
-      id: solverId,
-    })}`,
+    `${baseUrl()}/solvers/${problemTypeId}/${solverId}/sub-routines`,
     {
       method: "GET",
       headers: {
@@ -123,18 +125,20 @@ export async function fetchSubRoutines(
     });
 }
 
-// export async function fetchMetaSolverSettings(
-//   problemTypeId: string
-// ): Promise<MetaSolverSetting[]> {
-//   return fetch(`${baseUrl()}/meta-solver/settings/${problemTypeId}`, {
-//     method: "GET",
-//     headers: {
-//       "Content-Type": "application/json",
-//     },
-//   })
-//     .then((response) => response.json())
-//     .catch((reason) => {
-//       console.log(reason);
-//       return [];
-//     });
-// }
+export async function fetchSolverSettings(
+  problemTypeId: string,
+  solverId: string
+): Promise<[]> {
+  return fetch(`${baseUrl()}/solvers/${problemTypeId}/${solverId}/settings`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  })
+    .then((response) => response.json())
+    .catch((reason) => {
+      console.error(reason);
+      alert(`Could not retrieve subroutines of solver ${solverId}.`);
+      return [];
+    });
+}

src/api/data-model/ProblemDto.ts

@@ -1,5 +1,6 @@
 import { ProblemState } from "./ProblemState";
 import { getInvalidSolutionObject, SolutionObject } from "./SolutionObject";
+import { SolverSetting } from "./SolverSettings";
 import { SubRoutineReferenceDto } from "./SubRoutineReferenceDto";
 
 export interface ProblemDto<T> {
@@ -9,6 +10,7 @@ export interface ProblemDto<T> {
   solution: SolutionObject;
   state: ProblemState;
   solverId?: string;
+  solverSettings: SolverSetting[];
   subProblems: SubRoutineReferenceDto[];
   error: string;
 }
@@ -20,6 +22,7 @@ export function getInvalidProblemDto<T>(): ProblemDto<T> {
     input: {} as T,
     solution: getInvalidSolutionObject(),
     solverId: "",
+    solverSettings: [],
     state: ProblemState.READY_TO_SOLVE,
     subProblems: [],
     typeId: "",

src/api/data-model/SolverSettings.ts

@@ -0,0 +1,33 @@
+export enum SolverSettingType {
+  INTEGER = "INTEGER",
+  DOUBLE = "DOUBLE",
+  CHECKBOX = "CHECKBOX",
+  TEXT = "TEXT",
+  SELECT = "SELECT",
+}
+
+export interface SolverSetting {
+  name: string;
+  description: string;
+  type: SolverSettingType;
+  required: boolean;
+}
+
+export interface RangeSetting extends SolverSetting {
+  min: number;
+  max: number;
+  value: number;
+}
+
+export interface CheckboxSetting extends SolverSetting {
+  state: boolean;
+}
+
+export interface TextSetting extends SolverSetting {
+  text: string;
+}
+
+export interface SelectSetting extends SolverSetting {
+  options: string[];
+  selectedOption: string;
+}

src/components/solvers/Graph/ProblemDetails.tsx

@@ -12,7 +12,9 @@ import {
 import { ReactNode } from "react";
 import { ProblemDto } from "../../../api/data-model/ProblemDto";
 import { ProblemState } from "../../../api/data-model/ProblemState";
+import { SettingsView } from "../settings/SettingsView";
 import { SolutionView } from "../SolutionView";
+import { useGraphUpdates } from "./ProblemGraphView";
 import { useSolvers } from "./SolverProvider";
 
 function getHumanReadableState(state: ProblemState) {
@@ -46,22 +48,35 @@ function getAccordionItem(label: string, content: ReactNode) {
 
 export const ProblemDetails = (props: { problemDto: ProblemDto<any> }) => {
   const { solvers, getSolvers } = useSolvers();
+  const { updateProblem } = useGraphUpdates();
 
   // Update solvers in case they are not loaded yet
   if (!solvers[props.problemDto.typeId]) getSolvers(props.problemDto.typeId);
 
+  const solver = solvers[props.problemDto.typeId]?.find(
+    (s) => s.id === props.problemDto.solverId
+  );
+
   return (
     <VStack gap="20px" align="start">
       <Textarea readOnly resize="vertical" value={props.problemDto.input} />
       <Text>
         <b>Status:</b> {getHumanReadableState(props.problemDto.state)}
       </Text>
       <Text>
-        <b>Solver:</b>{" "}
-        {solvers[props.problemDto.typeId]?.find(
-          (s) => s.id === props.problemDto.solverId
-        )?.name ?? "-"}
+        <b>Solver:</b> {solver?.name ?? "-"}
       </Text>
+      {solver && (
+        <VStack width="100%" align="stretch">
+          <Text>Solver Settings:</Text>
+          <SettingsView
+            problemDto={props.problemDto}
+            settingsChanged={(settings) => {
+              updateProblem(props.problemDto.id);
+            }}
+          />
+        </VStack>
+      )}
       {props.problemDto.subProblems.length === 0 ? (
         <b>No subroutines</b>
       ) : (