과정 별칭 관리

과정 별칭을 사용하여 다른 이름으로 과정을 참조할 수 있습니다. 과정 별칭은 Google 클래스룸 과정 식별자와 외부 과정 식별자 간의 매핑 역할을 할 수 있습니다. 예를 들어 학생 정보 시스템 (SIS)의 강의 ID와 일치하도록 강의 별칭을 설정할 수 있습니다.

과정 별칭에는 도메인 전체 및 프로젝트 전체의 두 가지 형식이 있습니다.

  • 도메인 전체 별칭은 접두사 d:를 사용하며 Classroom API를 사용하는 모든 사용자가 볼 수 있습니다. 도메인 네임스페이스는 모든 사용자가 액세스해야 하지만 특정 프로그램에 국한되지 않는 별칭을 만드는 데 유용합니다. 예를 들어 MATH 127 및 COMSCI 127과 같은 과정의 대체 등록정보는 도메인 네임스페이스에 만들어야 합니다. 도메인 네임스페이스의 별칭은 도메인 관리자만 만들 수 있지만 도메인의 모든 사용자에게 표시됩니다.

  • 프로젝트 전반의 별칭은 p: 접두사를 사용하며 이를 만든 Google Cloud 프로젝트에서만 보고 사용할 수 있습니다. 개발자 프로젝트 네임스페이스는 애플리케이션별 별칭을 관리하는 데 유용합니다. 예를 들어 과정에 대체 식별자를 사용하는 애플리케이션은 별칭을 만들어 식별자를 클래스룸 과정에 매핑할 수 있습니다. 이 네임스페이스에서 만든 별칭은 특정 Google Cloud 프로젝트에 연결됩니다. 애플리케이션의 모든 사용자는 해당 애플리케이션의 개발자 프로젝트에 대한 네임스페이스에서 별칭을 만들고 볼 수 있습니다.

수업 별칭은 모든 Classroom API 엔드포인트의 클래스룸 수업 ID 대신 사용할 수 있습니다. 즉, 별칭을 사용하여 과정 및 명단 정보를 읽고 수정할 수 있습니다.

학생 정보 시스템과의 동기화에 별칭 사용

강의의 SIS 내부 식별자는 강의의 도메인 전용 별칭으로 등록할 수 있습니다. 이렇게 하면 SIS와 클래스룸을 모두 통합하는 모든 개발자가 SIS 식별자를 사용하여 클래스룸 데이터와 상호작용할 수 있습니다.

SIS에서 강의를 만들거나 강의를 SIS에 연결하는 경우 SIS의 강의 ID를 강의 별칭으로 사용하는 것이 좋습니다. courses.create() 메서드를 사용하여 과정을 만들 때 요청의 id 필드에 별칭을 지정할 수 있습니다. 별칭이 이미 있으면 409 ALREADY_EXISTS 오류와 함께 과정 생성이 실패합니다. 이렇게 하면 동기화 프로그램에 문제가 있는 경우 중복 과정이 생성되지 않습니다.

예를 들어 SIS 이름이 school이고 SIS에서 특정 과정에 사용하는 내부 식별자가 math_101라고 가정하면 별칭을 d:school_math_101로 만들 수 있습니다.

새 강의의 별칭 추가하기

새 과정의 별칭을 추가하려면 courses.create() 요청을 할 때 course.id를 별칭으로 설정합니다.

Apps Script자바Python
classroom/snippets/createAlias.gs
/**
 * Creates Course with an alias specified
 */
function createAlias() {
  let course = {
    id: 'p:bio_101',
    name: '10th Grade Biology',
    section: 'Period 2',
    descriptionHeading: 'Welcome to 10th Grade Biology',
    description: 'We\'ll be learning about the structure of living creatures from a combination ' +
      'of textbooks, guest lectures, and lab work. Expect to be excited!',
    room: '301',
    ownerId: 'me',
    courseState: 'PROVISIONED'
  };
  try {
    // Create the course using course details.
    course = Classroom.Courses.create(course);
    console.log('Course created: %s (%s)', course.name, course.id);
  } catch (err) {
    // TODO (developer) - Handle Courses.create() exception
    console.log('Failed to create course %s with an error %s', course.name, err.message);
  }
}
classroom/snippets/src/main/java/CreateCourseWithAlias.java
Course course = null;

/* Create a new Course with the alias set as the id field. Project-wide aliases use a prefix
of "p:" and can only be seen and used by the application that created them. */
Course content =
    new Course()
        .setId("p:history_4_2022")
        .setName("9th Grade History")
        .setSection("Period 4")
        .setDescriptionHeading("Welcome to 9th Grade History.")
        .setOwnerId("me")
        .setCourseState("PROVISIONED");

try {
  course = service.courses().create(content).execute();
  // Prints the new created course id and name
  System.out.printf("Course created: %s (%s)\n", course.getName(), course.getId());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 409) {
    System.out.printf("The course alias already exists: %s.\n", content.getId());
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return course;
classroom/snippets/classroom_add_alias_new.py
SCOPES = ["https://www.googleapis.com/auth/classroom.courses"]


def classroom_add_alias_new():
  """
  Creates a course with alias specification the user 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.
  """
  # pylint: disable=maybe-no-member
  creds = None
  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())

  alias = "d:school_physics_333"
  course = {
      "id": alias,
      "name": "English",
      "section": "Period 2",
      "description": "Course Description",
      "room": "301",
      "ownerId": "me",
  }
  try:
    print("-------------")
    service = build("classroom", "v1", credentials=creds)
    course = service.courses().create(body=course).execute()
    print("====================================")

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


if __name__ == "__main__":
  # pylint: disable=too-many-arguments
  # Put the course_id of course whose alias needs to be created.
  classroom_add_alias_new()

기존 과정의 별칭 추가

기존 과정에 별칭을 추가하려면 alias 필드를 설정하고 courses.aliases.create() 메서드를 사용하면 됩니다.

Apps Script자바Python
classroom/snippets/addAlias.gs
/**
 * Updates the section and room of Google Classroom.
 * @param {string} course_id
 * @see https://developers.google.com/classroom/reference/rest/v1/courses.aliases/create
 */
function addAlias(course_id) {
  const alias = {
    'alias': 'p:bio_101'
  };
  try {
    const course_alias = Classroom.Courses.Aliases.create(resource=alias, courseId=course_id);
    console.log('%s successfully added as an alias!', course_alias.alias);
  } catch (err) {
    // TODO (developer) - Handle exception
    console.log('Request to add alias %s failed with error %s.', alias.alias, err.message);
  }
}
classroom/snippets/src/main/java/AddAliasToCourse.java
/* Create a new CourseAlias object with a project-wide alias. Project-wide aliases use a prefix
of "p:" and can only be seen and used by the application that created them. */
CourseAlias content = new CourseAlias().setAlias("p:biology_10");
CourseAlias courseAlias = null;

try {
  courseAlias = service.courses().aliases().create(courseId, content).execute();
  System.out.printf("Course alias created: %s \n", courseAlias.getAlias());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 409) {
    System.out.printf("The course alias already exists: %s.\n", content);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return courseAlias;
classroom/snippets/classroom_add_alias_existing.py
def classroom_add_alias_existing(course_id):
  """
  Adds alias 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
  service = build("classroom", "v1", credentials=creds)
  alias = "d:school_math_101"
  course_alias = {"alias": alias}
  try:
    course_alias = (
        service.courses()
        .aliases()
        .create(courseId=course_id, body=course_alias)
        .execute()
    )
    return course_alias
  except HttpError as error:
    print(f"An error occurred: {error}")
    print("Alias Creation Failed")
  return course_alias


if __name__ == "__main__":
  # Put the course_id of course whose alias needs to be added.
  classroom_add_alias_existing(456058313539)

과정 별칭 가져오기

다음 샘플과 같이 courses.aliases.list() 메서드를 사용하여 과정의 별칭을 가져올 수 있습니다.

.NET자바Python
classroom/snippets/ClassroomSnippets/ListCourseAliases.cs
using System;
using System.Collections.Generic;
using Google;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Classroom.v1;
using Google.Apis.Classroom.v1.Data;
using Google.Apis.Services;

namespace ClassroomSnippets
{
    // Class to demonstrate the use of Classroom List Alias API
    public class ListCourseAliases
    {
        /// <summary>
        /// Retrieve the aliases for a course.
        /// </summary>
        /// <param name="courseId">Id of the course.</param>
        /// <returns>list of course aliases, null otherwise.</returns>
        public static List<CourseAlias> ClassroomListAliases(string courseId)
        {
            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.ClassroomCourses);

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

                string pageToken = null;
                var courseAliases = new List<CourseAlias>();

                do
                {
                    // List of aliases of specified course
                    var request = service.Courses.Aliases.List(courseId);
                    request.PageSize = 100;
                    request.PageToken = pageToken;
                    var response = request.Execute();
                    courseAliases.AddRange(response.Aliases);
                    pageToken = response.NextPageToken;
                } while (pageToken != null);

                if (courseAliases.Count == 0)
                {
                    Console.WriteLine("No aliases found.");
                }
                else
                {
                    Console.WriteLine("Aliases:");
                    foreach (var courseAlias in courseAliases)
                    {
                        Console.WriteLine(courseAlias.Alias);
                    }
                }
                return courseAliases;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is GoogleApiException)
                {
                    Console.WriteLine("Course does not exist.");
                }

                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}
classroom/snippets/src/main/java/ListCourseAliases.java
String pageToken = null;
List<CourseAlias> courseAliases = new ArrayList<>();

try {
  // List of aliases of specified course
  do {
    ListCourseAliasesResponse response =
        service
            .courses()
            .aliases()
            .list(courseId)
            .setPageSize(100)
            .setPageToken(pageToken)
            .execute();
    courseAliases.addAll(response.getAliases());
    pageToken = response.getNextPageToken();
  } while (pageToken != null);

  if (courseAliases.isEmpty()) {
    System.out.println("No aliases found.");
  } else {
    System.out.println("Aliases:");
    for (CourseAlias courseAlias : courseAliases) {
      System.out.println(courseAlias.getAlias());
    }
  }
} catch (GoogleJsonResponseException e) {
  // TODO(developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.err.println("Course does not exist.\n");
  } else {
    throw e;
  }
}
return courseAliases;

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


def classroom_list_course_aliases(course_id):
  """
  Prints the list of the aliases of a specified course 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()
  try:
    service = build("classroom", "v1", credentials=creds)
    course_aliases = []
    page_token = None

    while True:
      response = (
          service.courses()
          .aliases()
          .list(pageToken=page_token, courseId=course_id)
          .execute()
      )
      course_aliases.extend(response.get("aliases", []))
      page_token = response.get("nextPageToken", None)
      if not page_token:
        break

    if not course_aliases:
      print("No course aliases found.")

    print("Course aliases:")
    for course_alias in course_aliases:
      print(f"{course_alias.get('alias')}")
    return course_aliases
  except HttpError as error:
    print(f"An error occurred: {error}")
    return error


if __name__ == "__main__":
  classroom_list_course_aliases("course_id")

이전
강의 만들기 및 관리