Typed online tests

curl https://api.evalezy.com/v1/exams \
  -H "X-API-Key: $EVALEZY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: test-ch6-life-processes-v1" \
  -d '{
    "title": "Chapter 6 Test: Life Processes",
    "mode": "typed",
    "external_ref": "lms-test-90311",
    "subject": "Biology",
    "level": "school",
    "class": "X",
    "open": true,
    "questions": [
      {
        "label": "1",
        "type": "mcq_single",
        "text": "Where does the breakdown of pyruvate to give carbon dioxide, water and energy take place?",
        "max_marks": 1,
        "negative_marks": 0.25,
        "options": [
          { "label": "A", "text": "Cytoplasm" },
          { "label": "B", "text": "Mitochondria" },
          { "label": "C", "text": "Chloroplast" },
          { "label": "D", "text": "Nucleus" }
        ],
        "correct_options": ["B"]
      },
      {
        "label": "2",
        "type": "mcq_multi",
        "text": "Which of these are products of photosynthesis?",
        "max_marks": 2,
        "options": [
          { "label": "A", "text": "Glucose" },
          { "label": "B", "text": "Oxygen" },
          { "label": "C", "text": "Carbon dioxide" }
        ],
        "correct_options": ["A", "B"]
      },
      {
        "label": "3",
        "type": "numeric",
        "text": "How many chambers does the human heart have?",
        "max_marks": 1,
        "answer": 4
      },
      {
        "label": "4",
        "type": "long_answer",
        "text": "Why is respiration considered an exothermic reaction? Explain.",
        "max_marks": 3,
        "model_answer": "During respiration, glucose is oxidised to carbon dioxide and water in the cells. This releases energy, so respiration is an exothermic reaction.",
        "rubric": {
          "criteria": [
            { "name": "Oxidation of glucose", "marks": 1, "guidance": "Glucose is oxidised to carbon dioxide and water." },
            { "name": "Energy released", "marks": 1, "guidance": "States that energy is released." },
            { "name": "Conclusion", "marks": 1, "guidance": "A reaction that releases energy is exothermic." }
          ]
        }
      }
    ]
  }'

resp = requests.post(
    f"{API}/exams",
    json={
        "title": "Chapter 6 Test: Life Processes",
        "mode": "typed",
        "external_ref": f"lms-test-{test.id}",
        "subject": "Biology",
        "level": "school",
        "open": True,
        "questions": [q.to_evalezy() for q in test.questions],
    },
    headers={**HEADERS, "Idempotency-Key": f"test-{test.id}-v{test.version}"},
    timeout=30,
)
resp.raise_for_status()
exam = resp.json()
test.evalezy_exam_id = exam["id"]

const res = await fetch(`${API}/exams`, {
  method: "POST",
  headers: { ...headers, "Idempotency-Key": `test-${test.id}-v${test.version}` },
  body: JSON.stringify({
    title: test.title,
    mode: "typed",
    external_ref: `lms-test-${test.id}`,
    subject: "Biology",
    level: "school",
    open: true,
    questions: test.questions.map(toEvalezyQuestion),
  }),
});
const exam = await res.json();

curl https://api.evalezy.com/v1/exams/$EXAM_ID/submissions \
  -H "X-API-Key: $EVALEZY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: attempt-7f3c9a" \
  -d '{
    "candidate": { "external_id": "user_58213", "name": "Diya Patel" },
    "answers": [
      { "question_label": "1", "option_labels": ["B"] },
      { "question_label": "2", "option_labels": ["A", "B"] },
      { "question_label": "3", "value": 4 },
      { "question_label": "4", "text": "In respiration glucose is broken down into carbon dioxide and water and energy is released. Since energy is released it is exothermic." }
    ],
    "metadata": { "attempt_id": "attempt-7f3c9a" }
  }'

def submit_attempt(attempt):
    resp = requests.post(
        f"{API}/exams/{attempt.test.evalezy_exam_id}/submissions",
        json={
            "candidate": {"external_id": attempt.user.id, "name": attempt.user.name},
            "answers": [a.to_evalezy() for a in attempt.answers],
            "metadata": {"attempt_id": attempt.id},
        },
        headers={**HEADERS, "Idempotency-Key": f"attempt-{attempt.id}"},
        timeout=30,
    )
    resp.raise_for_status()
    sub = resp.json()
    attempt.submission_id = sub["id"]
    return sub

// POST /attempts/:id/submit in your backend
app.post("/attempts/:id/submit", async (req, res) => {
  const attempt = await db.attempts.get(req.params.id);
  const r = await fetch(`${API}/exams/${attempt.examId}/submissions`, {
    method: "POST",
    headers: { ...headers, "Idempotency-Key": `attempt-${attempt.id}` },
    body: JSON.stringify({
      candidate: { external_id: attempt.userId, name: attempt.userName },
      answers: attempt.answers, // [{ question_label, text | option_labels | value }]
      metadata: { attempt_id: attempt.id },
    }),
  });
  const sub = await r.json();
  if (!r.ok) return res.status(502).json({ error: sub.error.code });
  await db.attempts.update(attempt.id, { submissionId: sub.id });
  res.json({ status: sub.status }); // the player starts polling your backend
});

import time

FINAL = {"graded", "partially_graded", "failed", "cancelled"}

def wait_for_result(submission_id, timeout_s=180):
    delay = 2
    deadline = time.monotonic() + timeout_s
    while time.monotonic() < deadline:
        sub = requests.get(f"{API}/submissions/{submission_id}",
                           headers=HEADERS, timeout=15).json()
        if sub["status"] in FINAL:
            return sub
        time.sleep(delay)
        delay = min(delay * 1.5, 10)
    return None  # still running: show "Results will appear here" and let your sync worker pick it up

const FINAL = new Set(["graded", "partially_graded", "failed", "cancelled"]);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function waitForResult(submissionId, timeoutMs = 180_000) {
  let delay = 2000;
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const sub = await (await fetch(`${API}/submissions/${submissionId}`, { headers })).json();
    if (FINAL.has(sub.status)) return sub;
    await sleep(delay);
    delay = Math.min(delay * 1.5, 10_000);
  }
  return null; // still running
}