Tworzenie nauczycieli i uczniów oraz zarządzanie nimi

Role ucznia i nauczyciela w Google Classroom określają rolę użytkownika na zajęciach. Użytkownik może być nauczycielem na jednych zajęciach i uczniem na innych. Określenie „uczeń” lub „nauczyciel” oznacza zestaw uprawnień dla konkretnego użytkownika na konkretnym kursie.

Uczniowie

Zasób Student reprezentuje użytkownika, który jest uczniem.

w konkretnym kursie. Uczniowie mogą wyświetlać informacje o zajęciach i przypisanych do nich nauczycielach.

nauczyciele,

Zasób Teacher reprezentuje użytkownika, który prowadzi konkretny kurs. Nauczyciele mogą wyświetlać i zmieniać szczegóły kursu, wyświetlać nauczycieli i uczniów oraz zarządzać dodatkowymi nauczycielami i uczniami. Każdy kurs ma nauczyciela głównego, czyli właściciela kursu, który może zarządzać ustawieniami, takimi jak przeniesienie własności kursu.

Uczniowie i nauczyciele są identyfikowani na podstawie unikalnego identyfikatora lub adresu e-mail użytkownika zwróconego przez interfejs Directory API. Obecny użytkownik może też odwołać się do własnego identyfikatora za pomocą skrótu "me".

Uprawnienia do bezpośredniego zarządzania za pomocą interfejsu Classroom API

Administratorzy, uczniowie i nauczyciele mają różne uprawnienia, gdy bezpośrednio dodają lub usuwają użytkowników z kursów za pomocą interfejsu Classroom API.

Administratorzy

Administratorzy domeny mogą pominąć proces zapraszania i bezpośrednio dodawać uczniów i nauczycieli do kursu, jeśli spełnione są te warunki:

  • Dodawany użytkownik należy do domeny administratora.
  • Główny nauczyciel zajęć lub właściciel zajęć należy do domeny administratora.

W przypadku użytkowników lub kursów spoza domeny administratora aplikacje muszą uzyskać zgodę użytkownika, wysyłając zaproszenie za pomocą metody invitations.create.

Uczniowie

Uczniowie mogą dodać się do kursu, dzwoniąc pod numer students.create i podając enrollmentCode kursu. enrollmentCode to unikalny identyfikator kursu, który jest uwzględniony w zasobie Course. W aplikacji internetowej Classroom enrollmentCode jest dostępny na karcie strumienia i na stronie z informacjami o kursie.

nauczyciele,

Nauczyciele nie mogą bezpośrednio dodawać użytkowników do zajęć. Muszą używać metody invitations.create, aby zapraszać uczniów i innych nauczycieli na zajęcia.

W tabeli poniżej znajdziesz informacje o tym, który użytkownik może wysyłać żądania do metod create i delete w przypadku zasobów Teacher i Student.

Administrator Nauczyciel Uczeń
CreateTeacher ✔️ ✖️ ✖️
DeleteTeacher ✔️ ✔️ ✖️
CreateStudent ✔️ ✖️ ✔️ 1
DeleteStudent ✔️ ✔️ ✔️ 2

1. Uczeń może dodać się do kursu tylko samodzielnie.

2 Uczeń może usunąć tylko siebie z zajęć.

Zarządzanie nauczycielami

Administratorzy domeny mogą bezpośrednio dodawać nauczycieli w swojej domenie do zajęć za pomocą teachers.create, jak pokazano w tym przykładzie:

.NET

classroom/snippets/ClassroomSnippets/AddTeacher.cs
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/snippets/src/main/java/AddTeacher.java
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
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 java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
import java.util.Arrays;

/* Class to demonstrate the use of Classroom Add Teacher API */
public class AddTeacher {

  /* Scopes required by this API call. If modifying these scopes, delete your previously saved
  tokens/ folder. */
  static ArrayList<String> SCOPES =
      new ArrayList<>(Arrays.asList(ClassroomScopes.CLASSROOM_ROSTERS));

  /**
   * 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.
   * @throws GeneralSecurityException - if a new instance of NetHttpTransport was not created.
   */
  public static Teacher addTeacher(String courseId, String teacherEmail)
      throws GeneralSecurityException, IOException {

    // Create the classroom API client.
    final NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
    Classroom service =
        new Classroom.Builder(
                HTTP_TRANSPORT,
                GsonFactory.getDefaultInstance(),
                ClassroomCredentials.getCredentials(HTTP_TRANSPORT, SCOPES))
            .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
<?php
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

classroom/snippets/classroom_add_teacher.py
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 = "gduser1@workspacesamples.dev"
  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)

Nauczyciele współprowadzący mogą usuwać innych nauczycieli z zajęć za pomocą metody teachers.delete. Spowoduje to tylko usunięcie wskazanego nauczyciela z kursu i nie wpłynie na jego przypisanie do innych kursów ani na jego profil użytkownika.

Zarządzanie właścicielami kursów

Administratorzy domeny mogą przenosić własność zajęć między nauczycielami. Więcej informacji znajdziesz w sekcji Aktualizowanie właściciela kursu.

Zarządzanie uczniami

Administratorzy domeny mogą bezpośrednio dodawać uczniów w swojej domenie za pomocą metody students.create. Jeśli uczeń dodaje się bezpośrednio do zajęć, wymagany jest symbol enrollmentCode.

.NET

classroom/snippets/ClassroomSnippets/AddStudent.cs
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/snippets/src/main/java/AddStudent.java
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
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 java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
import java.util.Arrays;

/* Class to demonstrate the use of Classroom Add Student API */
public class AddStudent {

  /* Scopes required by this API call. If modifying these scopes, delete your previously saved
  tokens/ folder. */
  static ArrayList<String> SCOPES =
      new ArrayList<>(Arrays.asList(ClassroomScopes.CLASSROOM_ROSTERS));

  /**
   * 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.
   * @throws GeneralSecurityException - if a new instance of NetHttpTransport was not created.
   */
  public static Student addStudent(String courseId, String enrollmentCode, String studentId)
      throws GeneralSecurityException, IOException {

    // Create the classroom API client.
    final NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
    Classroom service =
        new Classroom.Builder(
                HTTP_TRANSPORT,
                GsonFactory.getDefaultInstance(),
                ClassroomCredentials.getCredentials(HTTP_TRANSPORT, SCOPES))
            .setApplicationName("Classroom samples")
            .build();

    Student student = new Student().setUserId(studentId);
    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
<?php
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

classroom/snippets/classroom_add_student.py
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": "gduser1@workspacesamples.dev"}
  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)

Usunięcie ucznia z kursu za pomocą metody students.delete powoduje usunięcie go tylko z określonego kursu i nie ma wpływu na jego rejestrację na innych kursach ani na jego profil użytkownika.

Pobieranie kursów użytkownika

Aby pobrać listę kursów dla ucznia lub nauczyciela, wywołaj courses.list i podaj odpowiedni identyfikator użytkownika studentId lub teacherId.

Nie możesz ustawić jednocześnie wartości studentId i teacherId w jednym żądaniu courses.list(). Aby pobrać listę kursów, na które zapisani są konkretny nauczyciel i uczeń, wyślij osobne żądania courses.list() dla każdego użytkownika. Następnie znajdź część wspólną obu zestawów wyników.

Pobieranie profilu użytkownika

Aby pobrać profil użytkownika, w tym jego identyfikator i nazwę, wywołaj funkcję userProfiles.get z identyfikatorem użytkownika, adresem e-mail lub ciągiem znaków „me” (dla użytkownika wysyłającego żądanie). Aby pobrać pole emailAddress, musisz uwzględnić zakres classroom.profile.emails.

Zwrócony znak id odpowiada zasobowi Users interfejsu Directory API zawierającemu pasujący znak studentId lub teacherId.

Dalej
Tworzenie zaproszeń na kursy i zarządzanie nimi