Kursarbeiten und Noten verwalten

Die Classroom-Benutzeroberfläche unterstützt fünf Arten von Kursaufgaben: das Tool „Aufgaben“, Aufgaben mit Quiz, Fragen mit Kurzantworten, Multiple-Choice-Fragen und Materialien. Die Classroom API unterstützt derzeit drei dieser Typen. werden als CourseWorkType für die API „Aufgaben“, „Kurzantwort“ bezeichnet. und Multiple-Choice-Fragen.

Um auf diese Funktion zuzugreifen, verwenden Sie den CourseWork-Ressource einer Aufgabe oder Frage, die Schülern in einem bestimmten Kurs, einschließlich zusätzlicher Materialien und Details wie oder der Höchstpunktzahl.

Neben der CourseWork-Ressource können Sie erledigte Aufgaben verwalten durch die Ressource StudentSubmission. In den folgenden Abschnitten werden diese im Detail an.

Aufgaben erstellen

Aufgaben können nur im Namen von Lehrkräften und Lehrkräften des Kurses erstellt werden. wenn Sie versuchen, im Namen eines Schülers/Studenten Aufgaben in einem Kurs zu erstellen, in einem 403-PERMISSION_DENIED-Fehler zurückgegeben. Domainadministratoren können ebenfalls keine Aufgaben für Kurse, die sie nicht leiten, und versuchen, dies über die API zu erledigen führt ebenfalls zu einem 403-Fehler PERMISSION_DENIED.

Wenn Sie Zuweisungen mit der Methode courses.courseWork.create erstellen, gehen Sie so vor: können Links als materials anhängen, wie im Beispielcode unten zu sehen:

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 ID, die als Referenz verwendet werden kann. die Zuweisung in anderen API-Anfragen.

So fügen Sie verknüpfte Materialien in eine Aufgabe ein, die über die Classroom API erstellt wurde: Verwenden Sie eine Linkressource und geben Sie Ziel-URL Classroom ruft automatisch den Titel und das Thumbnail ab. Die Classroom API unterstützt außerdem nativ Google Drive- und YouTube-Materialien, in einer DriveFile-Ressource enthalten oder YouTubeVideo-Ressource in einer ähnlichen

Wenn Sie einen Abgabetermin angeben möchten, setzen Sie die Felder dueDate und dueTime auf den entsprechende UTC-Zeit. Das Fälligkeitsdatum muss in der Zukunft liegen.

Aufgaben und Fragen abrufen

Sie können Aufgaben und Fragen für Schüler/Studenten und Lehrkräfte der für den entsprechenden Kurs oder einen Domainadministrator. Um eine bestimmte Aufgabe oder Frage, verwenden Sie "courses.courseWork.get". Alle abrufen Aufgaben oder Fragen (optional, die einige Kriterien erfüllen), verwenden courses.courseWork.list.

Der erforderliche Bereich hängt von der Rolle ab, die der anfragende Nutzer im . Wenn der Nutzer ein Schüler oder 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 eine der folgenden Optionen: Umfänge:

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

Eine Berechtigung zum Abrufen einer Aufgabe oder Frage ist nicht automatisch Berechtigungen für den Zugriff auf Materialien oder Materialmetadaten. In der Praxis bedeutet das, dass ein Administrator den Titel einer angehängten Drive-Datei möglicherweise nicht sieht, kein Mitglied des Kurses. Wenn Sie Administratoren Zugriff auf den erhalten Sie unter Domainweite Delegierung .

Antworten von Schülern und Studenten verwalten

StudentSubmission Ressource die geleistete und benotete Arbeit eines Schülers/Studenten für eine Aufgabe oder Frage. StudentSubmission wird implizit für jeden Schüler/Studenten erstellt, wenn eine neue Frage oder Aufgabe erstellt.

In den folgenden Abschnitten werden gängige Aktionen erläutert, mit denen die Antworten von Schülern und Studenten verwaltet werden.

Antworten von Schülern/Studenten abrufen

Schüler/Studenten können ihre eigenen Aufgaben abrufen, Lehrkräfte können Aufgaben abrufen und Domainadministratoren können alle abgegebenen Aufgaben für alle Schüler/Studenten in ihrer Domain. Jede abgegebene Aufgabe eines Schülers/Studenten einer Kennung zugewiesen ist, wenn Sie die ID kennen, verwenden Sie courses.courseWork.studentSubmissions.get, um sie abzurufen.

Verwenden Sie die Methode courses.courseWork.studentSubmissions.list, um StudentSubmission Ressourcen, die bestimmten Kriterien entsprechen, wie in der folgendes Beispiel:

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)

StudentSubmission-Ressourcen eines bestimmten Schülers/Studenten abrufen, indem Dabei wird der Parameter userId angegeben, 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")

Schüler/Studenten werden anhand ihrer eindeutigen ID oder E-Mail-Adresse identifiziert: die vom Google Admin SDK zurückgegeben werden. Der aktuelle Nutzer kann auch auf seine eigenen ID mithilfe der Abkürzung "me".

Es ist auch möglich, abgegebene Aufgaben für alle Aufgaben innerhalb eines . Dazu verwenden Sie das Literal "-" als courseWorkId, wie in den folgendes Beispiel:

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 Bereich hängt von der Rolle ab, die der anfragende Nutzer im . Verwenden Sie den folgenden Bereich, wenn der Nutzer eine Lehrkraft oder eine Domain ist Administrator:

  • 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/Student ist:

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

Die Erlaubnis zum Abrufen einer abgegebenen Aufgabe von Schülern oder Studenten bedeutet nicht, Berechtigungen für den Zugriff auf Anhänge oder Metadaten von Anhängen. In der Praxis bedeutet das kann es vorkommen, dass ein Administrator den Titel einer angehängten Drive-Datei nicht sehen kann, wenn kein Mitglied des Kurses. Wenn Sie Administratoren Zugriff gewähren möchten auf Nutzerdateien finden, Leitfaden für die domainweite Delegierung.

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

Sie können an die Aufgabe eines Schülers/Studenten Links anhängen, indem Sie Folgendes anhängen: Link, DriveFile- oder YouTubeVideo-Ressource. Dies geschieht mit courses.courseWork.studentSubmissions.modifyAttachments, wie in den folgendes Beispiel:

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 wird automatisch den Titel und das Thumbnail abrufen. Informationen zu den anderen Materialien finden Sie unter ihre jeweiligen Referenzseiten.

Das StudentSubmission kann nur von einer Lehrkraft oder von die Person, der sie gehört. Sie können Materials nur anhängen, wenn das CourseWorkType der eingereichten Inhalte des Schülers/Studenten betragen ASSIGNMENT.

Der erforderliche Bereich hängt von der Rolle ab, die der anfragende Nutzer im . Wenn der Nutzer eine Lehrkraft ist, verwenden Sie den folgenden Bereich:

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

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

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

Antwortstatus der Schüler/Studenten verwalten

Die Antwort eines Schülers oder Studenten kann zurückgezogen, abgegeben oder zurückgegeben werden. Das Feld „state“ in StudentSubmission gibt den aktuellen Status an. Rufen Sie zum Ändern des Status eine der folgenden Methoden:

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 oder Studenten, dem ein StudentSubmission gehört, kann es abgeben oder zurückfordern. Nur eine abgegebene Aufgabe kann zurückgefordert werden. Lehrkräfte können nur StudentSubmission mit dem Status „Abgegeben“

Antworten der Schüler/Studenten benoten

Die Ressource StudentSubmission hat zwei Felder zum Speichern von Noten: assignedGrade, die Note, die den Schülern/Studenten mitgeteilt wird, und draftGrade, Dies ist eine vorläufige Note, die nur für Lehrkräfte sichtbar ist. Diese Felder wurden aktualisiert courses.courseWork.studentSubmissions.patch mit einer Feldmaske verwenden die die entsprechenden Felder enthalten, 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()

Mit der Classroom-Benutzeroberfläche können Lehrkräfte erst eine Note vergeben, wenn sie haben zuerst einen Notenentwurf gespeichert. Die zugewiesene Note kann dann an Schüler oder Studenten. Anwendungen müssen dieses Verhalten emulieren. Ihre Anwendung kann Sie haben zwei Möglichkeiten, die Aufgabe eines Schülers/Studenten zu benoten:

  • Weisen Sie nur die draftGrade zu. Dies ist beispielsweise nützlich, damit die Lehrkraft die Noten manuell zu überprüfen, bevor Sie sie abschließen. Schüler/Studenten können keine Notenentwürfe sehen.

  • Weisen Sie sowohl draftGrade als auch assignedGrade zu, um eine Aufgabe vollständig zu benoten.

Zugewiesene Noten auflisten

Sie können alle Noten für eine bestimmte Kursaufgabe auflisten, indem Sie die courses.courseWork.studentSubmissions.list-Antwortobjekt:

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'))}")