Ta strona została przetłumaczona przez Cloud Translation API.

Załączniki zewnętrzne i oddanie

To siódmy przewodnik z serii dodatków do Classroom.

Z tego przewodnika dowiesz się, jak dodać zachowanie do aplikacji internetowej, aby tworzyć załączniki dodatków spoza Google Classroom. Wykorzystaj ten sposób, aby umożliwić użytkownikom tworzenie załączników dodatków na podstawie istniejących usług lub witryn. Jest to też doskonałe uzupełnienie integracji CourseWork, ponieważ pozwala kierować obecny ruch do ulepszonej wersji usługi oferowanej przez dodatek, nie zmieniając przepływu pracy. Sugerowany proces omówiliśmy na stronie przewodnika Tworzenie załączników poza Classroom.

Dodajesz też działanie do dodatku, aby automatycznie modyfikować projekt z załącznikami. Możesz modyfikować każde zadanie, które ma jeden z załączników dodatków, niezależnie od tego, kto je utworzył. Jest to szczególnie przydatne w przypadku oddawania projektów po ukończeniu zadania przez ucznia. Zasygnalizuje to nauczycielowi, że przypisane zadania zostały wykonane, a zadanie jest gotowe do sprawdzenia.

Rozszerzasz ostateczną wersję dodatku, która obsługuje załączniki typu content-type lub activity-type. W tym przewodniku używany jest załącznik typu content-type.

Dodaj zakres protokołu OAuth do zarządzania przypisaniami

Upewnij się, że aplikacja żąda tych zakresów:

https://www.googleapis.com/auth/classroom.addons.teacher
https://www.googleapis.com/auth/classroom.addons.student
https://www.googleapis.com/auth/classroom.coursework.students

Zakres classroom.coursework.students nie był wcześniej potrzebny. Możesz go użyć do tworzenia lub modyfikowania przypisań CourseWork. Dodaj ten zakres do list zakresów w pakiecie SDK Google Workspace Marketplace, ekranie akceptacji OAuth i kodzie serwera w projekcie Cloud.

Python

  SCOPES = [
    "https://www.googleapis.com/auth/classroom.addons.teacher",
    "https://www.googleapis.com/auth/classroom.addons.student",
    "https://www.googleapis.com/auth/classroom.coursework.students",
  ]

Tworzenie projektu w Classroom

Dodawanie przycisków do strony internetowej bez elementów iframe

Proces opisany w tym przewodniku umożliwia użytkownikowi tworzenie projektów i załączników w Google Classroom z poziomu usługi niepochodzącej od Google. W praktyce jest to prawdopodobnie istniejąca witryna lub aplikacja. W tym przykładzie należy utworzyć próbną stronę internetową, która będzie pełnić funkcję witryny zewnętrznej. Aby utworzyć nowe przypisanie, musisz mieć przycisk lub link, które po kliknięciu otwierają nową trasę, która wykona sugerowany przepływ w CourseWork.

W razie potrzeby musisz też dodać przycisk lub link umożliwiający użytkownikowi zalogowanie się. Do kolejnych żądań do interfejsu API będą potrzebne dane logowania użytkownika, więc muszą oni uzgadniać połączenie OAuth 2.0. Szczegółowe informacje znajdziesz w instrukcji logowania.

Python

Podany przykład Pythona modyfikuje trasę /index, która została wprowadzona w pierwszym kroku przewodnika.

<!-- /webapp/templates/index.html -->
<a href="clear-credentials.html">Logout</a>
<a href="start-auth-flow.html">Login</a>

<br>

<a href="create-coursework-assignment.html">Create a CourseWork Assignment</a>

Dodaj szablon HTML reprezentujący miejsce docelowe w Twojej witrynie. Będzie ona zawierać treści, które zostaną dołączone do projektu CourseWork.

<!-- /webapp/templates/example-coursework-assignment.html -->
<h1>CourseWork assignment loaded!</h1>
<p>You've loaded a CourseWork assignment! It was created from an external web page.</p>

Utwórz nowy plik modułu Pythona do obsługi tras związanych z CourseWork. W podanym przykładzie jest to wartość coursework_routes.py. Dodaj te 3 trasy. Pamiętaj, że część zawartości podasz później.

# /webapp/coursework_routes.py
@app.route("/create-coursework-assignment")
def create_coursework_assignment():
  """
  Completes the assignment creation flow.
  """

  # Check that the user is signed in. If not, perform the OAuth 2.0
  # authorization flow.
  credentials = get_credentials()

  if not credentials:
    return start_auth_flow("coursework_assignment_callback")

  # Construct the Google Classroom service.
  classroom_service = get_classroom_service()

  pass  # To be completed later.

@app.route("/example-coursework-assignment/<assignment_type>")
def example_coursework_assignment(assignment_type):
  """
  Renders the "example-coursework-assignment.html" template.
  """
  return flask.render_template(
      "example-coursework-assignment.html", assignment_type=assignment_type
  )

@app.route("/coursework-assignment-callback")
def coursework_assignment_callback():
  """
  Completes the OAuth 2.0 handshake and stores credentials in the session.
  This is identical to the callback introduced in the sign-in walkthrough,
  but redirects the user to the index page instead of the attachment
  discovery page.
  """
  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE,
      scopes=SCOPES,
      state=flask.session["state"],
      redirect_uri=flask.url_for("coursework_assignment_callback", _external=True),
  )

  flow.fetch_token(authorization_response=flask.request.url)

  credentials = flow.credentials
  flask.session["credentials"] = session_credentials_to_dict(
      credentials
  )

  # Close the current window and redirect the user to the index page.
  return flask.render_template("close-me.html", redirect_destination="index")

Sprawdzanie uprawnień użytkownika do tworzenia dodatków

Jest kilka wymagań wstępnych, które użytkownik musi spełnić, zanim będzie można tworzyć załączniki dodatków w jego imieniu. Dla wygody Google udostępnia metodę courses.checkAddOnCreationEligibility do określania, czy użytkownik spełnia te wymagania wstępne. Użytkownik, który spełnia wymagania wstępne, jest nazywany użytkownikiem spełniającym wymagania.

Dodaj kontrolę dostępności do implementacji trasy tworzenia CourseWork. Następnie przetestuj pole isCreateAttachmentEligible w odpowiedzi. W przypadku kwalifikujących się użytkowników utwórz projekt z załącznikiem zgodnie z zasadami, aby je utworzyć. W przeciwnym razie utwórz materiał linku. Musisz znać identyfikator zajęć, w których użytkownik chce utworzyć projekt. Zazwyczaj prosimy użytkownika o wybranie kursu. Dla uproszczenia w tym przykładzie używamy wartości zakodowanej na stałe w kodzie.

Python

# /webapp/coursework_routes.py
@app.route("/create-coursework-assignment")
def create_coursework_assignment():
  """
  Completes the assignment creation flow.
  """
  # ... Check that the user is signed in and get the Classroom service ...

  # The ID of the course to which the assignment will be added.
  course_id = 1234567890  # TODO(developer) Replace with an actual course ID.

  # Check whether the user can create add-on attachments.
  eligibility_response = (
      classroom_service.courses()
      .checkAddOnCreationEligibility(courseId=course_id)
      .execute()
  )
  is_create_attachment_eligible = eligibility_response.get("isCreateAttachmentEligible")

  if is_create_attachment_eligible:
    # See the "Create an assignment with add-on attachment for eligible users" section for implementation.
  if not is_create_attachment_eligible:
    # See the "Create a Link Material" section for implementation.

Utwórz projekt z załącznikiem dodatku dla kwalifikujących się użytkowników

Jeśli użytkownik ma uprawnienia do tworzenia załączników dodatków, wykonaj te czynności:

Wyślij żądanie do interfejsu API, aby utworzyć courseWork projekt w Google Classroom bez bez załączników.
Wyodrębnij id z nowo utworzonego projektu.
Utwórz nowy obiekt CourseWorkAddOnAttachment.
Wyślij prośbę o utworzenie załącznika dodatku do nowo utworzonego projektu w Google Classroom.

Python

# /webapp/coursework_routes.py
if is_create_attachment_eligible:
  # Create an assignment.
  coursework = {
      "title": "My CourseWork Assignment with Add-on Attachment",
      "description": "Created using the Classroom CourseWork API.",
      "workType": "ASSIGNMENT",
      "state": "DRAFT",  # Set to 'PUBLISHED' to assign to students.
  }

  # Issue a request to create the assignment.
  create_assignment_response = (
      classroom_service.courses()
      .courseWork()
      .create(courseId=course_id, body=coursework)
      .execute()
  )

  # Create an add-on attachment that links to the selected content and
  # associate it with the new assignment.
  content_url = flask.url_for(
      "example_coursework_assignment",
      assignment_type="add-on-attachment",
      _scheme="https",
      _external=True,
  )

  # Construct an AddOnAttachment instance.
  attachment = {
      "teacherViewUri": {"uri": content_url},
      "studentViewUri": {"uri": content_url},
      "title": f'Test Attachment for Assignment {create_assignment_response.get("id")}',
  }

  # Issue a request to create the attachment.
  add_on_attachment_response = (
      classroom_service.courses()
      .courseWork()
      .addOnAttachments()
      .create(
          courseId=course_id,
          itemId=create_assignment_response.get("id"),  # ID of the new assignment.
          body=attachment,
      )
      .execute()
  )

Utwórz materiał linku

Jeśli użytkownik nie ma uprawnień do tworzenia załączników dodatków, utwórz materiał linku, wykonując te czynności:

Python

if not is_create_attachment_eligible:
    coursework = {
        "title": "My CourseWork Assignment with Link Material",
        "description": "Created using the Classroom CourseWork API.",
        "workType": "ASSIGNMENT",
        "state": "DRAFT",  # Set to 'PUBLISHED' to assign to students.
        # Specify the URL for your content as a Link Material.
        "materials": [
            {
                "link": {
                    "url": flask.url_for(
                        "example_coursework_assignment",
                        assignment_type="link-material",
                        _scheme="https",
                        _external=True,
                    )
                }
            }
        ],
    }

    # Issue a request to create the assignment.
    assignment_response = (
        classroom_service.courses()
        .courseWork()
        .create(courseId=course_id, body=coursework)
        .execute()
    )

Modyfikowanie utworzonego wcześniej projektu

Masz dostęp do dowolnego elementu strumienia w Google Classroom, który ma co najmniej jeden z załączników, możesz go modyfikować, oddać, odzyskać lub zwrócić, niezależnie od tego, kto utworzył ten element. Elementy strumienia to dowolne przypisanie Announcement, CourseWork lub CourseWorkMaterial.

Aby to zademonstrować, dodasz trasę, by zmodyfikować dany element strumienia. Użyj tej metody, aby sprawdzić, czy masz dostęp do elementów strumienia utworzonych przez Ciebie za pomocą interfejsu API oraz utworzonych przez nauczyciela za pomocą interfejsu Google Classroom, i możesz je modyfikować.

Dodaj jeszcze jeden link lub przycisk do strony internetowej edytowanej po raz pierwszy w tym przewodniku. Powinno otworzyć się nową trasę, aby zmodyfikować przypisanie CourseWork.

Python

Podany przykład Pythona modyfikuje trasę /index, która została zmodyfikowana wcześniej w tym przewodniku.

<!-- /webapp/templates/index.html -->
<a href="modify-coursework-assignment.html">Create a CourseWork Assignment</a>

Utwórz nową trasę do obsługi tras związanych z CourseWork. Znajduje się to w pliku coursework_routes.py w podanym przykładzie.

# Check that the user is signed in.
credentials = get_credentials()

if not credentials:
  return start_auth_flow("coursework_assignment_callback")

# Get the Google Classroom service.
classroom_service = get_classroom_service()

# The ID of the course to which the assignment will be added.
# Ordinarily, you'll prompt the user to specify which course to use. For
# simplicity, we use a hard-coded value in this example.
course_id = 1234567890  # TODO(developer) Replace with an actual course ID.
assignment_id = 1234567890  # TODO(developer) Replace with an actual assignment ID.

# Retrieve details about the CourseWork assignment.
get_coursework_response = (
    classroom_service.courses()
    .courseWork()
    .get(courseId=course_id, id=assignment_id)
    .execute()
)

# Alter the current title.
assignment_title = f"{get_coursework_response.get('title')} (Modified by API request)"

# Issue a request to modify the assignment.
modify_coursework_response = (
    classroom_service.courses()
    .courseWork()
    .patch(
        courseId=course_id,
        id=assignment_id,
        updateMask="title",
        body={"title": assignment_title},
    )
    .execute()
)

Testowanie dodatku

Dla uproszczenia w podanych przykładach wykorzystano zakodowane na stałe identyfikatory zajęć i projektów. Możesz uzyskać te identyfikatory, wysyłając żądania z danymi logowania nauczyciela do metod get i list zasobów courses i courseWork. Są one też zwracane w odpowiedzi podczas tworzenia courseWork projektów.

Tworzenie materiału linku testowego

Uruchom serwer, a następnie przejdź na stronę indeksu i zaloguj się jako nauczyciel bez licencji Google Workspace for Education Teaching & Learning lub Plus. W konsoli administracyjnej domeny testowej możesz przełączać stan licencji użytkownika.Kliknij przycisk Utwórz projekt na zajęciach, a następnie otwórz interfejs Google Classroom i sprawdź, czy utworzono projekt z załączonym materiałem. Załącznik powinien zawierać tytuł strony internetowej, do której prowadzi link, oraz adres URL.

Testowanie tworzenia załącznika dodatku

Wróć na stronę indeksu i zaloguj się jako nauczyciel z licencją Google Workspace for Education Teaching and Learning lub Plus. Kliknij przycisk Create a CourseWork Assignment a następnie otwórz interfejs Google Classroom i sprawdź, czy utworzono projekt z załącznikiem dodatku. Załącznik powinien zawierać nazwę aplikacji dodatku oraz tytuł określony w kodzie.

Modyfikowanie przypisania testowego

Wróć na stronę indeksu i sprawdź, czy logujesz się jako nauczyciel z licencją Teaching & Learning lub Plus. Kliknij przycisk Zmodyfikuj projekt CourseWork, a następnie wróć do interfejsu Google Classroom i sprawdź, czy tytuł projektu został zmieniony.

Gratulacje! Masz już za sobą całą serię przewodników.