Kursarbeiten und Noten verwalten

Die Classroom-Benutzeroberfläche unterstützt fünf Arten von Kursaufgaben: Aufgaben, Quizaufgaben, Fragen mit Kurzantworten, Multiple-Choice-Fragen und Materialien. Die Classroom API unterstützt derzeit drei dieser Typen. Diese werden in der API als CourseWorkType bezeichnet: Aufgaben, Kurzantwort-Fragen und Multiple-Choice-Fragen.

Materials an Ressourcen vom Typ CourseWorkType: Aufgaben, Kurzantwort- und Multiple-Choice-Fragen.

Für den Zugriff auf diese Funktion können Sie die Ressource CourseWork verwenden. Sie steht für eine Aufgabe oder Frage, die den Teilnehmern eines bestimmten Kurses zugewiesen wurde, einschließlich zusätzlicher Materialien und Details wie Abgabetermin oder maximale Punktzahl.

Neben der Ressource „Kurswork“ können Sie abgeschlossene Aufgaben mit der Ressource StudentSubmission verwalten. In den folgenden Abschnitten werden diese genauer beschrieben.

Aufgaben erstellen

Aufgaben können nur im Namen der Lehrkraft(n) des Kurses erstellt werden. Wenn Sie versuchen, in einem Kurs Aufgaben im Namen eines Schülers oder Studenten zu erstellen, wird der Fehler 403 PERMISSION_DENIED ausgegeben. Ebenso können Domainadministratoren keine Aufgaben für Kurse erstellen, die sie nicht unterrichten. Ein Versuch, dies über die API zu tun, führt ebenfalls zu einem 403-Fehler PERMISSION_DENIED.

Wenn Sie Zuweisungen mit der Methode courses.courseWork.create erstellen, können Sie Links als materials anhängen, wie im folgenden Beispielcode gezeigt:

Java

classroom/snippets/src/main/java/CreateCourseWork.java
CourseWork courseWork = null;
try {
  // Create a link to add as a material on course work.
  Link articleLink =
      new Link()
          .setTitle("SR-71 Blackbird")
          .setUrl("https://www.lockheedmartin.com/en-us/news/features/history/blackbird.html");

  // Create a list of Materials to add to course work.
  List<Material> materials = Arrays.asList(new Material().setLink(articleLink));

  /* Create new CourseWork object with the material attached.
  Set workType to `ASSIGNMENT`. Possible values of workType can be found here:
  https://developers.google.com/classroom/reference/rest/v1/CourseWorkType
  Set state to `PUBLISHED`. Possible values of state can be found here:
  https://developers.google.com/classroom/reference/rest/v1/courses.courseWork#courseworkstate */
  CourseWork content =
      new CourseWork()
          .setTitle("Supersonic aviation")
          .setDescription(
              "Read about how the SR-71 Blackbird, the world’s fastest and "
                  + "highest-flying manned aircraft, was built.")
          .setMaterials(materials)
          .setWorkType("ASSIGNMENT")
          .setState("PUBLISHED");

  courseWork = service.courses().courseWork().create(courseId, content).execute();

  /* Prints the created courseWork. */
  System.out.printf("CourseWork created: %s\n", courseWork.getTitle());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf("The courseId does not exist: %s.\n", courseId);
  } else {
    throw e;
  }
  throw e;
} catch (Exception e) {
  throw e;
}
return courseWork;

Python

classroom/snippets/classroom_create_coursework.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_create_coursework(course_id):
  """
  Creates the coursework the user has access to.
  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """

  creds, _ = google.auth.default()
  # pylint: disable=maybe-no-member

  try:
    service = build("classroom", "v1", credentials=creds)
    coursework = {
        "title": "Ant colonies",
        "description": """Read the article about ant colonies
                              and complete the quiz.""",
        "materials": [
            {"link": {"url": "http://example.com/ant-colonies"}},
            {"link": {"url": "http://example.com/ant-quiz"}},
        ],
        "workType": "ASSIGNMENT",
        "state": "PUBLISHED",
    }
    coursework = (
        service.courses()
        .courseWork()
        .create(courseId=course_id, body=coursework)
        .execute()
    )
    print(f"Assignment created with ID {coursework.get('id')}")
    return coursework

  except HttpError as error:
    print(f"An error occurred: {error}")
    return error


if __name__ == "__main__":
  # Put the course_id of course whose coursework needs to be created,
  # the user has access to.
  classroom_create_coursework(453686957652)

Das Ergebnis enthält eine vom Server zugewiesene Kennung, mit der die Zuweisung in anderen API-Anfragen referenziert werden kann.

Wenn Sie verknüpfte Materialien in eine Aufgabe aufnehmen möchten, die über die Classroom API erstellt wurde, verwenden Sie eine Linkressource und geben Sie die Ziel-URL an. Classroom ruft automatisch den Titel und die Miniaturansicht ab. Die Classroom API unterstützt außerdem Google Drive- und YouTube-Materialien, die auf ähnliche Weise in eine DriveFile-Ressource oder eine YouTubeVideo-Ressource enthalten sind.

Wenn Sie ein Fälligkeitsdatum angeben möchten, legen Sie für die Felder dueDate und dueTime die entsprechende UTC-Zeit fest. Das Fälligkeitsdatum muss in der Zukunft liegen.

Aufgaben und Fragen abrufen

Sie können Aufgaben und Fragen für Teilnehmer und Lehrkräfte des entsprechenden Kurses oder von einem Domainadministrator abrufen. Um eine bestimmte Aufgabe oder Frage abzurufen, verwenden Sie „courses.courseWork.get“. Mit „courses.courseWork.list“ können Sie alle Aufgaben oder Fragen abrufen, die optional mit bestimmten Kriterien übereinstimmen.

Der erforderliche Umfang hängt von der Rolle ab, die der anfragende Nutzer im Kurs hat. Wenn der Nutzer Student ist, verwenden Sie einen der folgenden Bereiche:

  • https://www.googleapis.com/auth/classroom.coursework.me.readonly
  • https://www.googleapis.com/auth/classroom.coursework.me

Wenn der Nutzer eine Lehrkraft oder ein Domainadministrator ist, verwenden Sie einen der folgenden Bereiche:

  • https://www.googleapis.com/auth/classroom.coursework.students.readonly
  • https://www.googleapis.com/auth/classroom.coursework.students

Die Berechtigung zum Abrufen einer Aufgabe oder Frage bedeutet nicht, dass Sie berechtigt sind, auf Materialien oder Materialmetadaten zuzugreifen. In der Praxis bedeutet dies, dass Administratoren den Titel einer angehängten Drive-Datei möglicherweise nicht sehen, wenn sie kein Kursmitglied sind. Informationen dazu, wie Sie Administratoren Zugriff auf Nutzerdateien gewähren, finden Sie im Leitfaden zur domainweiten Delegierung.

Antworten von Schülern/Studenten verwalten

Eine StudentSubmission-Ressource steht für die geleistete Arbeit und die Note eines Schülers/Studenten bei einer Aufgabe oder Frage. Wenn eine neue Frage oder Aufgabe erstellt wird, wird implizit für jeden Schüler/Studenten eine StudentSubmission-Ressource erstellt.

In den folgenden Abschnitten werden häufige Aktionen beschrieben, mit denen die Antworten von Schülern oder Studenten verwaltet werden.

Antworten von Schülern/Studenten abrufen

Lernende können ihre eigenen Aufgaben abrufen, Lehrkräfte können Beiträge für alle Teilnehmer in ihren Kursen abrufen und Domainadministratoren können alle Einreichungen für alle Schüler/Studenten in ihrer Domain abrufen. Jeder Einreichung von Schülern/Studenten wird eine ID zugewiesen. Wenn Sie die ID kennen, können Sie sie mit courses.courseWork.studentSubmissions.get abrufen.

Verwenden Sie die Methode courses.courseWork.studentSubmissions.list, um StudentSubmission-Ressourcen abzurufen, die bestimmten Kriterien entsprechen, wie im folgenden Beispiel gezeigt:

Java

classroom/snippets/src/main/java/ListSubmissions.java
List<StudentSubmission> studentSubmissions = new ArrayList<>();
String pageToken = null;

try {
  do {
    ListStudentSubmissionsResponse response =
        service
            .courses()
            .courseWork()
            .studentSubmissions()
            .list(courseId, courseWorkId)
            .setPageToken(pageToken)
            .execute();

    /* Ensure that the response is not null before retrieving data from it to avoid errors. */
    if (response.getStudentSubmissions() != null) {
      studentSubmissions.addAll(response.getStudentSubmissions());
      pageToken = response.getNextPageToken();
    }
  } while (pageToken != null);

  if (studentSubmissions.isEmpty()) {
    System.out.println("No student submission found.");
  } else {
    for (StudentSubmission submission : studentSubmissions) {
      System.out.printf(
          "Student id (%s), student submission id (%s)\n",
          submission.getUserId(), submission.getId());
    }
  }
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s) or courseWorkId (%s) does not exist.\n", courseId, courseWorkId);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmissions;

Python

classroom/snippets/classroom_list_submissions.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_list_submissions(course_id, coursework_id):
  """
  Creates the courses the user has access to.
  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """

  creds, _ = google.auth.default()
  # pylint: disable=maybe-no-member
  submissions = []
  page_token = None

  try:
    service = build("classroom", "v1", credentials=creds)
    while True:
      coursework = service.courses().courseWork()
      response = (
          coursework.studentSubmissions()
          .list(
              pageToken=page_token,
              courseId=course_id,
              courseWorkId=coursework_id,
              pageSize=10,
          )
          .execute()
      )
      submissions.extend(response.get("studentSubmissions", []))
      page_token = response.get("nextPageToken", None)
      if not page_token:
        break

    if not submissions:
      print("No student submissions found.")

    print("Student Submissions:")
    for submission in submissions:
      print(
          "Submitted at:"
          f"{(submission.get('id'), submission.get('creationTime'))}"
      )

  except HttpError as error:
    print(f"An error occurred: {error}")
    submissions = None
  return submissions


if __name__ == "__main__":
  # Put the course_id and coursework_id of course whose list needs to be
  # submitted.
  classroom_list_submissions(453686957652, 466086979658)

Rufen Sie StudentSubmission-Ressourcen ab, die zu einem bestimmten Studenten gehören. Geben Sie dazu den Parameter userId an, wie im folgenden Beispiel gezeigt:

Java

classroom/snippets/src/main/java/ListStudentSubmissions.java
List<StudentSubmission> studentSubmissions = new ArrayList<>();
String pageToken = null;

try {
  do {
    // Set the userId as a query parameter on the request.
    ListStudentSubmissionsResponse response =
        service
            .courses()
            .courseWork()
            .studentSubmissions()
            .list(courseId, courseWorkId)
            .setPageToken(pageToken)
            .set("userId", userId)
            .execute();

    /* Ensure that the response is not null before retrieving data from it to avoid errors. */
    if (response.getStudentSubmissions() != null) {
      studentSubmissions.addAll(response.getStudentSubmissions());
      pageToken = response.getNextPageToken();
    }
  } while (pageToken != null);

  if (studentSubmissions.isEmpty()) {
    System.out.println("No student submission found.");
  } else {
    for (StudentSubmission submission : studentSubmissions) {
      System.out.printf("Student submission: %s.\n", submission.getId());
    }
  }

Python

classroom/snippets/classroom_list_student_submissions.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_list_student_submissions(course_id, coursework_id, user_id):
  """
  Creates the courses the user has access to.
  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """

  creds, _ = google.auth.default()
  # pylint: disable=maybe-no-member
  submissions = []
  page_token = None

  try:
    service = build("classroom", "v1", credentials=creds)
    while True:
      coursework = service.courses().courseWork()
      response = (
          coursework.studentSubmissions()
          .list(
              pageToken=page_token,
              courseId=course_id,
              courseWorkId=coursework_id,
              userId=user_id,
          )
          .execute()
      )
      submissions.extend(response.get("studentSubmissions", []))
      page_token = response.get("nextPageToken", None)
      if not page_token:
        break

    if not submissions:
      print("No student submissions found.")

    print("Student Submissions:")
    for submission in submissions:
      print(
          "Submitted at:"
          f"{(submission.get('id'), submission.get('creationTime'))}"
      )

  except HttpError as error:
    print(f"An error occurred: {error}")
  return submissions


if __name__ == "__main__":
  # Put the course_id, coursework_id and user_id of course whose list needs
  # to be submitted.
  classroom_list_student_submissions(453686957652, 466086979658, "me")

Die Lernenden werden durch die eindeutige ID oder E-Mail-Adresse des Nutzers identifiziert, die vom Google Admin SDK zurückgegeben wird. Der aktuelle Nutzer kann auch mit dem Kürzel "me" auf seine eigene ID verweisen.

Es ist auch möglich, abgegebene Aufgaben für alle Aufgaben eines Kurses abzurufen. Verwenden Sie dazu das Literal "-" als courseWorkId, wie im folgenden Beispiel gezeigt:

Java

service.courses().courseWork().studentSubmissions()
    .list(courseId, "-")
    .set("userId", userId)
    .execute();

Python

service.courses().courseWork().studentSubmissions().list(
    courseId=<course ID or alias>,
    courseWorkId='-',
    userId=<user ID>).execute()

Der erforderliche Umfang hängt von der Rolle ab, die der anfragende Nutzer im Kurs hat. Verwenden Sie den folgenden Bereich, wenn der Nutzer eine Lehrkraft oder ein Domainadministrator ist:

  • https://www.googleapis.com/auth/classroom.coursework.students.readonly
  • https://www.googleapis.com/auth/classroom.coursework.students

Verwenden Sie den folgenden Bereich, wenn der Nutzer ein Schüler ist:

  • https://www.googleapis.com/auth/classroom.coursework.me.readonly
  • https://www.googleapis.com/auth/classroom.coursework.me

Eine Berechtigung zum Abrufen von Aufgaben von Schülern oder Studenten bedeutet nicht automatisch, dass sie auf Anhänge oder Metadaten von Anhängen zugreifen dürfen. In der Praxis bedeutet dies, dass Administratoren, die kein Kursmitglied sind, möglicherweise den Titel einer angehängten Drive-Datei nicht sehen. Informationen dazu, wie Sie Administratoren Zugriff auf Nutzerdateien gewähren, finden Sie in der Anleitung zur domainweiten Delegierung.

Anhänge zu einer Antwort von Schülern/Studenten hinzufügen

Sie können Links an eine von Schülern/Studenten abgegebene Aufgabe anhängen, indem Sie eine Ressource vom Typ Link, DriveFile oder YouTubeVideo anhängen. Dazu verwenden Sie courses.courseWork.studentSubmissions.modifyAttachments, wie im folgenden Beispiel gezeigt:

Java

classroom/snippets/src/main/java/ModifyAttachmentsStudentSubmission.java
StudentSubmission studentSubmission = null;
try {
  // Create ModifyAttachmentRequest object that includes a new attachment with a link.
  Link link = new Link().setUrl("https://en.wikipedia.org/wiki/Irrational_number");
  Attachment attachment = new Attachment().setLink(link);
  ModifyAttachmentsRequest modifyAttachmentsRequest =
      new ModifyAttachmentsRequest().setAddAttachments(Arrays.asList(attachment));

  // The modified studentSubmission object is returned with the new attachment added to it.
  studentSubmission =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .modifyAttachments(courseId, courseWorkId, id, modifyAttachmentsRequest)
          .execute();

  /* Prints the modified student submission. */
  System.out.printf(
      "Modified student submission attachments: '%s'.\n",
      studentSubmission.getAssignmentSubmission().getAttachments());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmission;

Python

Classroom/snippets/classroom_add_attachment.py
def classroom_add_attachment(course_id, coursework_id, submission_id):
  """
  Adds attachment to existing course with specific course_id.
  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()
  # pylint: disable=maybe-no-member
  request = {
      "addAttachments": [
          {"link": {"url": "http://example.com/quiz-results"}},
          {"link": {"url": "http://example.com/quiz-reading"}},
      ]
  }

  try:
    service = build("classroom", "v1", credentials=creds)
    while True:
      coursework = service.courses().courseWork()
      coursework.studentSubmissions().modifyAttachments(
          courseId=course_id,
          courseWorkId=coursework_id,
          id=submission_id,
          body=request,
      ).execute()

  except HttpError as error:
    print(f"An error occurred: {error}")


if __name__ == "__main__":
  # Put the course_id, coursework_id and submission_id of course in which
  # attachment needs to be added.
  classroom_add_attachment("course_id", "coursework_id", "me")

Ein Linkanhang wird durch die Ziel-URL definiert. Classroom ruft automatisch den Titel und die Miniaturansicht ab. Informationen zu den anderen Materialien finden Sie auf den entsprechenden Referenzseiten.

Das StudentSubmission kann nur von einem Kursleiter oder vom Kursteilnehmer geändert werden, dem es gehört. Sie können Materials nur anhängen, wenn CourseWorkType der abgegebenen Aufgabe des Schülers/Studenten ASSIGNMENT ist.

Der erforderliche Umfang hängt von der Rolle ab, die der anfragende Nutzer im Kurs hat. Verwenden Sie den folgenden Bereich, wenn der Nutzer eine Lehrkraft ist:

  • https://www.googleapis.com/auth/classroom.coursework.students

Verwenden Sie den folgenden Bereich, wenn der Nutzer ein Schüler ist:

  • https://www.googleapis.com/auth/classroom.coursework.me

Antwortstatus von Schülern/Studenten verwalten

Die Antwort eines Schülers oder Studenten kann zurückgezogen, abgegeben oder zurückgegeben werden. Das Statusfeld in StudentSubmission gibt den aktuellen Status an. Rufen Sie eine der folgenden Methoden auf, um den Status zu ändern:

Alle diese Methoden verwenden einen leeren Textkörper. Beispiel:

Java

classroom/snippets/src/main/java/ReturnStudentSubmission.java
try {
  service
      .courses()
      .courseWork()
      .studentSubmissions()
      .classroomReturn(courseId, courseWorkId, id, null)
      .execute();
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}

Python

service.courses().courseWork().studentSubmission().turnIn(
    courseId=<course ID or alias>,
    courseWorkId=<courseWork ID>,
    id=<studentSubmission ID>,
    body={}).execute()

Nur der Schüler/Student, dem ein StudentSubmission gehört, kann es abgeben oder zurückfordern. Nur abgegebene Aufgaben können zurückgefordert werden. Kurslehrkräfte können nur ein StudentSubmission zurückgeben, das den Status „Abgegeben“ hat.

Antworten von Schülern/Studenten benoten

Die Ressource StudentSubmission hat zwei Felder, in denen Noten gespeichert werden: assignedGrade – die Note, die den Schülern oder Studenten gemeldet wird, und draftGrade – eine vorläufige Note, die nur für Lehrkräfte sichtbar ist. Diese Felder werden mithilfe von courses.courseWork.studentSubmissions.patch mit einer Feldmaske aktualisiert, die die entsprechenden Felder enthält, wie im folgenden Beispiel gezeigt.

Java

classroom/snippets/src/main/java/PatchStudentSubmission.java
StudentSubmission studentSubmission = null;
try {
  // Updating the draftGrade and assignedGrade fields for the specific student submission.
  StudentSubmission content =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .get(courseId, courseWorkId, id)
          .execute();
  content.setAssignedGrade(90.00);
  content.setDraftGrade(80.00);

  // The updated studentSubmission object is returned with the new draftGrade and assignedGrade.
  studentSubmission =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .patch(courseId, courseWorkId, id, content)
          .set("updateMask", "draftGrade,assignedGrade")
          .execute();

  /* Prints the updated student submission. */
  System.out.printf(
      "Updated student submission draft grade (%s) and assigned grade (%s).\n",
      studentSubmission.getDraftGrade(), studentSubmission.getAssignedGrade());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmission;

Python

studentSubmission = {
  'assignedGrade': 99,
  'draftGrade': 80
}
service.courses().courseWork().studentSubmissions().patch(
    courseId=<course ID or alias>,
    courseWorkId=<courseWork ID>,
    id=<studentSubmission ID>,
    updateMask='assignedGrade,draftGrade',
    body=studentSubmission).execute()

Wenn Lehrkräfte die Classroom-Benutzeroberfläche verwenden, können Lehrkräfte erst dann eine Note zuweisen, wenn sie zum ersten Mal einen Notenentwurf gespeichert haben. Die Note kann dann an die Lernenden zurückgegeben werden. Anwendungen müssen dieses Verhalten emulieren. Ihre Anwendung kann die Aufgabe eines Schülers/Studenten auf zwei Arten benoten:

  • Weisen Sie nur draftGrade zu. Dies ist beispielsweise nützlich, damit die Lehrkraft Noten vor der Fertigstellung manuell überprüfen kann. Schüler/Studenten können keine Notenentwürfe sehen.

  • Weisen Sie draftGrade und assignedGrade zu, um eine Aufgabe vollständig zu benoten.

Zugewiesene Noten auflisten

Mit dem Antwortobjekt der Methode courses.courseWork.studentSubmissions.list können Sie alle Noten für ein bestimmtes Kursaufgabenelement auflisten:

Java

classroom/snippets/src/main/java/ListStudentSubmissions.java
  ListStudentSubmissionsResponse response =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .list(courseId, courseWorkId)
          .setPageToken(pageToken)
          .execute();

  /* Ensure that the response is not null before retrieving data from it to avoid errors. */
  if (response.getStudentSubmissions() != null) {
    studentSubmissions.addAll(response.getStudentSubmissions());
    pageToken = response.getNextPageToken();
  }
} while (pageToken != null);

if (studentSubmissions.isEmpty()) {
  System.out.println("No student submissions found.");
} else {
  for (StudentSubmission submission : studentSubmissions) {
    System.out.printf(
        "User ID %s, Assigned grade: %s\n",
        submission.getUserId(), submission.getAssignedGrade());
  }
}

Python

response = coursework.studentSubmissions().list(
    courseId=course_id,
    courseWorkId=coursework_id,
    pageSize=10).execute()
submissions.extend(response.get('studentSubmissions', []))

if not submissions:
    print('No student submissions found.')

print('Student Submissions:')
for submission in submissions:
    print(f"Submitted at:"
          f"{(submission.get('userId'), submission.get('assignedGrade'))}")