Zarządzaj nauczycielami i uczniami

Uczniowie i nauczyciele to konkretne mapowanie między profilem użytkownika a kursem, które reprezentuje jego rolę na zajęciach. Wyznaczenia uczniów i nauczycieli nie są globalne: użytkownik może zostać przypisany jako nauczyciel na jednych zajęciach, a uczeń na innych. Określenie „uczeń” lub „nauczyciel” oznacza zbiór uprawnień użytkownika w ramach określonych kursów.

Uczniowie

Zasób dla ucznia reprezentuje użytkownika, który jest zarejestrowany na zajęciach na określonych zajęciach. Uczniowie mogą wyświetlać szczegóły i nauczycieli zajęć.

Nauczyciele

Zasób dla nauczyciela reprezentuje użytkownika, który prowadzi konkretny kurs. Nauczyciele mogą wyświetlać i zmieniać szczegóły zajęć, wyświetlać nauczycieli i uczniów oraz zarządzać dodatkowymi nauczycielami i uczniami.

Uwaga: jeśli konto nauczyciela głównego zostanie usunięte, zanim własność zajęć zostanie przeniesiona na nauczyciela współprowadzącego, niektóre funkcje zajęć i funkcje interfejsu API nie będą działać. Więcej informacji znajdziesz w artykule Przenoszenie własności zajęć.

Uczniowie i nauczyciele są identyfikowani na podstawie unikalnych identyfikatorów i adresów e-mail, które są zwracane przez interfejs Directory API. Bieżący użytkownik może również odwoływać się do swojego identyfikatora za pomocą skrótu "me".

Dodawanie bezpośrednie

Administratorzy domeny mogą pomijać proces zapraszania i bezpośrednio dodawać użytkowników w domenie jako nauczycieli lub uczniów do zajęć w swojej domenie. Kurs jest traktowany w ramach domeny administratora, jeśli jego właściciel należy do domeny administratora. W przypadku użytkowników i kursów spoza domeny uwierzytelnionego administratora domeny aplikacje muszą uzyskać zgodę użytkownika, wysyłając zaproszenie za pomocą metody invitations.create().

Dodawanie i usuwanie nauczycieli

Administratorzy domen mogą bezpośrednio dodawać nauczycieli do swoich domen za pomocą teachers.create(), tak jak w tym przykładzie:

.NET

classroom/snippets/ClassroomFragments/AddTeacher.cs

Wyświetl w GitHubie

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

Wyświetl w GitHubie

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

Wyświetl w GitHubie

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/fragments/classroom_add_teacher.py

Wyświetl w GitHubie

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)

Jeśli dodajesz nauczycieli w imieniu uwierzytelnionego nauczyciela, musisz użyć metody invitations.create().

Możesz usunąć nauczycieli z zajęć za pomocą metody teachers.delete(). Spowoduje to tylko usunięcie z zajęć tych nauczycieli i nie wpłynie na ich przypisanie do innych zajęć czy do profilu użytkownika.

Rejestrowanie i usuwanie uczniów

Administratorzy domeny mogą bezpośrednio dodawać uczniów w domenie za pomocą metody students.create(), jak pokazujemy w tym przykładzie:

.NET

classroom/snippets/ClassroomFragments/AddStudent.cs

Wyświetl w GitHubie

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

Wyświetl w GitHubie

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 (w języku angielskim)

Wyświetl w GitHubie

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/fragmenty/classroom_add_student.py

Wyświetl w GitHubie

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)

Uwaga: jeśli osoba zgłaszająca prośbę jest uczniem, właściwość enrollmentCode jest wymagana.

Jeśli dodajesz uczniów w imieniu uwierzytelnionego nauczyciela, musisz użyć metody invitations.create().

Możesz usunąć ucznia z zajęć za pomocą metody students.delete(). Spowoduje to usunięcie tylko tych uczniów z zajęć i nie wpłynie na ich rejestrację w innych kursach ani na profilu użytkownika.

Pobieranie kursów użytkownika

Aby pobrać listę kursów dla ucznia lub nauczyciela, wywołaj metodę courses.list() i podaj odpowiednią wartość właściwości studentId lub teacherId użytkownika.

Pobieranie profilu użytkownika

Aby pobrać skrócony profil, w tym identyfikator i nazwę użytkownika, wywołaj metodę userProfiles.get() z identyfikatorem użytkownika, adresem e-mail lub „mną” użytkownika, który wysłał prośbę.

Aby pobrać pole emailAddress, musisz uwzględnić zakres classroom.profile.emails.

Zwrócony identyfikator odpowiada zasobowi użytkowników Directory API zawierającym pasujący studentId lub teacherId.

Zarządzanie właścicielami zajęć

Administratorzy domeny mogą przenosić własność zajęć między nauczycielami. Ważne informacje znajdziesz w sekcji Przenoszenie własności kursu.