Lehrkräfte und Schüler oder Studenten verwalten

Schüler, Studenten und Lehrkräfte sind spezifische Verknüpfungen zwischen einem Nutzerprofil und einem Kurs, die die Rolle dieses Nutzers im Kurs darstellen. Die Bezeichnungen „Student“ und „Lehrer“ sind nicht global: Ein Nutzer kann als Lehrkraft für einen Kurs und für einen anderen Teilnehmer zugewiesen werden. Die Bezeichnung „Student“ oder „Lehrkraft“ stellt eine Reihe von Berechtigungen für einen bestimmten Nutzer in einem bestimmten Kurs dar.

Kursteilnehmer

Eine Schülerressource stellt einen Nutzer dar, der als Schüler in einem bestimmten Kurs eingeschrieben ist. Schüler/Studenten können sich die Kursdetails und die Lehrkräfte für diesen Kurs ansehen.

Lehrer

Eine Lehrkraft ist ein Nutzer, der einen bestimmten Kurs unterrichtet. Lehrkräfte dürfen die Kursdetails ansehen und ändern, Lehrkräfte und Schüler/Studenten ansehen sowie zusätzliche Lehrkräfte und Schüler oder Studenten verwalten.

Hinweis:Wenn das primäre Lehrkraftkonto gelöscht wird, bevor die Inhaberschaft des Kurses auf eine zusätzliche Lehrkraft übertragen wird, funktionieren einige Kurs- und API-Funktionen für diesen Kurs nicht mehr.

Schüler/Studenten und Lehrkräfte werden anhand der eindeutigen ID oder E-Mail-Adresse des Nutzers identifiziert, die vom Google Admin SDK zurückgegeben wird. Der aktuelle Nutzer kann sich auch mithilfe des "me"-Kurzbefehls auf seine eigene ID beziehen.

Direkt hinzufügen

Domainadministratoren können den Einladungsablauf umgehen und Nutzer innerhalb ihrer Domain direkt als Lehrkräfte oder Schüler oder Studenten zu Kursen in ihrer Domain hinzufügen. Ein Kurs gilt als innerhalb der Domain des Administrators, wenn er sich in der Domain des Administrators befindet. Für Nutzer oder Kurse außerhalb der Domain eines authentifizierten Domainadministrators müssen Anwendungen die Einwilligung des Nutzers einholen, indem sie eine Einladung mit der Methode invitations.create() senden.

Lehrkräfte hinzufügen oder entfernen

Domainadministratoren können Lehrkräfte innerhalb ihrer Domain direkt mit teachers.create() zu Kursen hinzufügen, wie im folgenden Beispiel gezeigt:

.NET

classroom/snippets/ClassroomSnippets/AddTeacher.cs

Auf GitHub ansehen

using Google.Apis.Auth.OAuth2;
using Google.Apis.Classroom.v1;
using Google.Apis.Classroom.v1.Data;
using Google.Apis.Services;
using System;
using System.Net;
using Google;

namespace ClassroomSnippets
{
    // Class to demonstrate the use of Classroom Create Teacher API
    public class AddTeacher
    {
       /// <summary>
       /// Add teacher to the Course
       /// </summary>
       /// <param name="courseId"></param>
       /// <param name="teacherEmail"></param>
       /// <returns></returns>
        public static Teacher ClassroomAddTeacher( string courseId,
                 string teacherEmail)
         {
             try 
             {
                 /* Load pre-authorized user credentials from the environment.
                  TODO(developer) - See https://developers.google.com/identity for 
                  guides on implementing OAuth2 for your application. */
                 GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                     .CreateScoped(ClassroomService.Scope.ClassroomRosters);

                 // Create Classroom API service.
                 var service = new ClassroomService(new BaseClientService.Initializer
                 {
                     HttpClientInitializer = credential,
                     ApplicationName = "Classroom API Snippet"
                 });

                 var teacher = new Teacher
                 {
                     UserId = teacherEmail
                 };
                 // Add the teacher to the course.
                 teacher = service.Courses.Teachers.Create(teacher, courseId).Execute();
                     Console.WriteLine(
                         "User '{0}' was added as a teacher to the course with ID '{1}'.\n",
                         teacher.Profile.Name.FullName, courseId);
                     return teacher;
             }
             catch (Exception e)
             {
                 // TODO(developer) - handle error appropriately
                 if (e is AggregateException)
                 {
                     Console.WriteLine("Credential Not found");
                 }
                 else if (e is GoogleApiException)
                 {
                     Console.WriteLine("Failed to Add the teacher. Error message: {0}", e.Message);
                 }
                 else
                 {
                     throw;
                 }
             }

             return null;
         }


    }

}

Java

Classroom/Ausschnitte/src/main/java/AddTeacher.java

Auf GitHub ansehen

import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.classroom.Classroom;
import com.google.api.services.classroom.ClassroomScopes;
import com.google.api.services.classroom.model.Teacher;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

/* Class to demonstrate the use of Classroom Add Teacher API */
public class AddTeacher {
  /**
   * Add teacher to a specific course.
   *
   * @param courseId     - Id of the course.
   * @param teacherEmail - Email address of the teacher.
   * @return newly created teacher
   * @throws IOException - if credentials file not found.
   */
  public static Teacher addTeacher(String courseId, String teacherEmail)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Collections.singleton(ClassroomScopes.CLASSROOM_ROSTERS));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Create the classroom API client
    Classroom service = new Classroom.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Classroom samples")
        .build();

    Teacher teacher = new Teacher().setUserId(teacherEmail);
    try {
      // Add a teacher to a specified course
      teacher = service.courses().teachers().create(courseId, teacher).execute();
      // Prints the course id with the teacher name
      System.out.printf("User '%s' was added as a teacher to the course with ID '%s'.\n",
          teacher.getProfile().getName().getFullName(), courseId);
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      GoogleJsonError error = e.getDetails();
      if (error.getCode() == 409) {
        System.out.printf("User '%s' is already a member of this course.\n", teacherEmail);
      } else if (error.getCode() == 403) {
        System.out.println("The caller does not have permission.\n");
      } else {
        throw e;
      }
    }
    return teacher;
  }
}

PHP

classroom/snippets/src/ClassroomAddTeacher.php

Auf GitHub ansehen

use Google\Client;
use Google\Service\Classroom;
use Google\Service\Classroom\Teacher;
use Google\service\Exception;

function addTeacher($courseId, $teacherEmail)
{
    /* Load pre-authorized user credentials from the environment.
    TODO (developer) - See https://developers.google.com/identity for
     guides on implementing OAuth2 for your application. */
    $client = new Client();
    $client->useApplicationDefaultCredentials();
    $client->addScope("https://www.googleapis.com/auth/classroom.profile.photos");
    $service = new Classroom($client);
    $teacher = new Teacher([
        'userId' => $teacherEmail
    ]);
    try {
        //  calling create teacher
        $teacher = $service->courses_teachers->create($courseId, $teacher);
        printf("User '%s' was added as a teacher to the course with ID '%s'.\n",
            $teacher->profile->name->fullName, $courseId);
    } catch (Exception $e) {
        if ($e->getCode() == 409) {
            printf("User '%s' is already a member of this course.\n", $teacherEmail);
        } else {
            throw $e;
        }
    }
    return $teacher;
}

Python

Kursraum/Auszüge/classroom_add_teacher.py

Auf GitHub ansehen

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_add_teacher(course_id):
    """
    Adds a teacher to a 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
    service = build('classroom', 'v1', credentials=creds)

    teacher_email = '[e-mail]'
    teacher = {
        'userId': teacher_email
    }

    try:
        teachers = service.courses().teachers()
        teacher = teachers.create(courseId=course_id,
                                  body=teacher).execute()
        print('User %s was added as a teacher to the course with ID %s'
              % (teacher.get('profile').get('name').get('fullName'),
                 course_id))
    except HttpError as error:
        print('User "{%s}" is already a member of this course.'
              % teacher_email)
        return error
    return teachers


if __name__ == '__main__':
    # Put the course_id of course for which Teacher needs to be added.
    classroom_add_teacher(453686957652)

Wenn Sie im Namen einer authentifizierten Lehrkraft weitere Lehrkräfte hinzufügen, müssen Sie die Methode invitations.create() verwenden.

Mit der Methode teachers.delete() können Sie weitere Lehrkräfte aus einem Kurs entfernen. Dadurch wird nur die angegebene Lehrkraft aus dem Kurs entfernt. Die Zuweisung zu anderen Kursen oder ihrem Nutzerprofil ist davon nicht betroffen.

Schüler oder Studenten anmelden oder entfernen

Domainadministratoren können Schüler und Studenten direkt innerhalb ihrer Domain mit der Methode students.create() hinzufügen, wie im folgenden Beispiel gezeigt:

.NET

classroom/snippets/ClassroomSnippets/AddStudent.cs

Auf GitHub ansehen

using Google.Apis.Auth.OAuth2;
using Google.Apis.Classroom.v1;
using Google.Apis.Classroom.v1.Data;
using Google.Apis.Services;
using System;
using System.Net;
using Google;

namespace ClassroomSnippets
{
    // Class to demonstrate the use of Classroom Create Student API
    public class AddStudent
    {
        public static Student ClassroomAddStudent(string courseId, string enrollmentCode)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for 
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(ClassroomService.Scope.ClassroomRosters);
                var service = new ClassroomService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Classroom API .NET Quickstart"
                });

                var student = new Student
                {
                    UserId = "me"
                };

                var request = service.Courses.Students.Create(student, courseId);
                request.EnrollmentCode = enrollmentCode;
                student = request.Execute();
                Console.WriteLine(
                    "User '{0}' was enrolled  as a student in the course with ID '{1}'.\n",
                    student.Profile.Name.FullName, courseId);
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is GoogleApiException)
                {
                    Console.WriteLine("Failed to Add the Student. Error message: {0}", e.Message);
                }
                else
                {
                    throw;
                }
            }

            return null;
        }
    }

}

Java

Classroom/Ausschnitte/src/main/java/AddStudent.java

Auf GitHub ansehen

import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.classroom.Classroom;
import com.google.api.services.classroom.ClassroomScopes;
import com.google.api.services.classroom.model.Student;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

/* Class to demonstrate the use of Classroom Add Student API */
public class AddStudent {
  /**
   * Add a student in a specified course.
   *
   * @param courseId       - Id of the course.
   * @param enrollmentCode - Code of the course to enroll.
   * @return newly added student
   * @throws IOException - if credentials file not found.
   */
  public static Student addStudent(String courseId, String enrollmentCode)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Collections.singleton(ClassroomScopes.CLASSROOM_ROSTERS));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Create the classroom API client
    Classroom service = new Classroom.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Classroom samples")
        .build();

    Student student = new Student().setUserId("[e-mail]");
    try {
      // Enrolling a student to a specified course
      student = service.courses().students().create(courseId, student)
          .setEnrollmentCode(enrollmentCode)
          .execute();
      // Prints the course id with the Student name
      System.out.printf("User '%s' was enrolled as a student in the course with ID '%s'.\n",
          student.getProfile().getName().getFullName(), courseId);
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      GoogleJsonError error = e.getDetails();
      if (error.getCode() == 409) {
        System.out.println("You are already a member of this course.");
      } else if (error.getCode() == 403) {
        System.out.println("The caller does not have permission.\n");
      } else {
        throw e;
      }
    }
    return student;
  }
}

PHP

classroom/snippets/src/ClassroomAddStudent.php

Auf GitHub ansehen

use Google\Client;
use Google\Service\Classroom;
use Google\Service\Classroom\Student;
use Google\Service\Exception;

function enrollAsStudent($courseId,$enrollmentCode)
{
    /* Load pre-authorized user credentials from the environment.
    TODO (developer) - See https://developers.google.com/identity for
     guides on implementing OAuth2 for your application. */
    $client = new Client();
    $client->useApplicationDefaultCredentials();
    $client->addScope("https://www.googleapis.com/auth/classroom.profile.emails");
    $service = new Classroom($client);
    $student = new Student([
        'userId' => 'me'
    ]);
    $params = [
        'enrollmentCode' => $enrollmentCode
    ];
    try {
        $student = $service->courses_students->create($courseId, $student, $params);
        printf("User '%s' was enrolled  as a student in the course with ID '%s'.\n",
            $student->profile->name->fullName, $courseId);
    } catch (Exception $e) {
        if ($e->getCode() == 409) {
            print "You are already a member of this course.\n";
        } else {
            throw $e;
        }
    }
    return $student;
}

Python

Kursraum/Auszüge/classroom_add_student.py

Auf GitHub ansehen

from __future__ import print_function

import os

from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

SCOPES = ['https://www.googleapis.com/auth/classroom.coursework.students']


def classroom_add_student_new(course_id):
    """
    Adds a student to a course, the teacher has access to.
    The file token.json stores the user's access and refresh tokens, and is
    created automatically when the authorization flow completes for the first
    time.
    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 = None
    # The file token.json stores the user's access and refresh tokens, and is
    # created automatically when the authorization flow completes for the first
    # time.
    if os.path.exists('token.json'):
        creds = Credentials.from_authorized_user_file('token.json', SCOPES)
    # If there are no (valid) credentials available, let the user log in.
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        # Save the credentials for the next run
        with open('token.json', 'w', encoding="utf8") as token:
            token.write(creds.to_json())

    enrollment_code = 'abc-def'
    student = {
            'userId': '[e-mail]'
        }
    try:
        service = build('classroom', 'v1', credentials=creds)
        student = service.courses().students().create(
                courseId=course_id,
                enrollmentCode=enrollment_code,
                body=student).execute()
        print(
                '''User {%s} was enrolled as a student in
                   the course with ID "{%s}"'''
                % (student.get('profile').get('name').get('fullName'),
                   course_id))
        return student
    except HttpError as error:
        print(error)
        return error


if __name__ == '__main__':
    # Put the course_id of course for which student needs to be added.
    classroom_add_student_new(478800920837)

Hinweis:Wenn der Anforderer ein Schüler oder Student ist, ist enrollmentCode erforderlich.

Wenn Sie Schüler oder Studenten im Namen einer authentifizierten Lehrkraft hinzufügen, müssen Sie die Methode invitations.create() verwenden.

Mit der Methode students.delete() können Sie einen Teilnehmer aus einem Kurs entfernen. Dadurch wird nur der angegebene Teilnehmer aus dem Kurs entfernt. Die Anmeldung in anderen Kursen oder in seinem Nutzerprofil ist davon nicht betroffen.

Kurse eines Nutzers abrufen

Um eine Liste der Kurse eines Schülers oder Studenten oder einer Lehrkraft abzurufen, rufen Sie courses.list() auf und geben Sie die studentId oder teacherId des entsprechenden Nutzers an.

Nutzerprofil abrufen

Um das gekürzte Profil, einschließlich ID und Name, für einen Nutzer abzurufen, rufen Sie userProfiles.get() mit der ID, E-Mail-Adresse oder „ich“ des Nutzers auf.

Zum Abrufen des Felds emailAddress müssen Sie den Bereich classroom.profile.emails einbeziehen.

Die zurückgegebene ID entspricht der Nutzerressource der Directory API, die die entsprechende studentId oder teacherId enthält.

Kursinhaberschaft übertragen

Domainadministratoren können die Inhaberschaft von Kursen zwischen Lehrkräften innerhalb ihrer Domain übertragen, indem sie die folgenden Methoden aufrufen:

1. Rufen Sie zuerst teachers.create() auf, um dem Kurs eine Lehrkraft hinzuzufügen, sofern diese noch keine zusätzliche Lehrkraft ist.

2. Rufen Sie dann courses.patch() auf und geben Sie im Feld ownerId des Anfrageobjekts die E-Mail-Adresse oder Nutzer-ID der zusätzlichen Lehrkraft an, um den Inhaber des Kurses zu aktualisieren.

Warnung: Übertragen Sie die Inhaberschaft des Kurses auf eine neue Lehrkraft, bevor das Konto des ursprünglichen Kursinhabers in der Admin-Konsole gelöscht wird. Wenn das Konto des ursprünglichen Kursinhabers in der Admin-Konsole gelöscht wird, bevor die oben genannten Schritte ausgeführt wurden, wird ein InactiveCourseOwner-Fehler ausgegeben. Der Domainadministrator muss das Konto des ursprünglichen Kursinhabers wiederherstellen und die Schritte zum Übertragen der Inhaberschaft wiederholen.