Załączniki zewnętrzne i oddanie

To jest siódmy przewodnik po dodatkach do Classroom. które zrecenzować w naszym serwisie.

Z tego przewodnika dowiesz się, jak dodać do aplikacji internetowej działanie, aby utworzyć dodatek załączniki spoza Google Classroom. Użyj tego sposobu działania, aby pozwolić użytkownicy tworzą załączniki dodatków na podstawie istniejącej usługi lub witryny. To jest może też stanowić świetne uzupełnienie integracji z CourseWork, ponieważ zarządzasz obecnymi do większej liczby użytkowników oferowanej przez Twój dodatek bez wprowadzania zmian ich płynność. Sugerowany proces jest omówiony w artykule Tworzenie załączników. poza Classroom.

Możesz też dodać zachowanie do dodatku, aby zmodyfikować projekt za pomocą dodatku . Możesz modyfikować wszystkie projekty, które mają jedną z tych wartości: załączniki dodatków niezależnie od tego, kto utworzył projekt. To jest szczególnie przydatne do oddawania projektów po ukończeniu zadanie, sygnalizując nauczycielowi, że zadania zostały ukończone jest gotowe do sprawdzenia.

Rozszerzasz ostateczną wersję dodatku, która obsługuje atrybut content-type lub załączniki związane z aktywnością. W tym przewodniku używamy załącznika typu treści.

Dodaj zakres protokołu OAuth do zarządzania projektami

Upewnij się, że Twoja 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 i jest używane do tworzenia lub modyfikowania CourseWork projektów. Dodaj ten zakres do list zakresów w projekcie Cloud pakiet SDK Google Workspace Marketplace, ekran zgody OAuth oraz kod serwera.

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 niezawierającej elementów iframe

Proces opisany w tym przewodniku pozwala użytkownikowi utworzyć projekty i załączniki w Google Classroom pochodzące z usług firm innych niż Google; W jest to zapewne Twoja witryna lub aplikacja. W tym przykładzie musisz utworzyć pozorowaną stronę internetową, która będzie działać jako witryna zewnętrzna. Potrzebujesz przycisku lub link, którego kliknięcie otwiera nową trasę wykonującą sugerowaną trasę CourseWork, aby utworzyć nowy projekt.

Musisz też dodać przycisk lub link umożliwiający użytkownikowi zalogowanie się, jeśli: nie mają jeszcze konta. Aby utworzyć kolejne, musisz podać dane logowania żądań do interfejsu API, więc muszą zakończyć uzgadnianie połączenia OAuth 2.0. Zobacz stronę logowania .

Python

Podany przykład Pythona modyfikuje wprowadzoną trasę /index w pierwszym kroku.

<!-- /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 witrynie. Ta strona będzie reprezentować treść, która zostanie dołączona do Twojego dokumentu CourseWork projektu.

<!-- /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. Jest to coursework_routes.py w podanym przykładzie. Dodaj następujące elementy trzy trasy; pamiętaj, że część treści wpiszesz 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, czy użytkownik może tworzyć dodatki

Istnieje kilka wymagań wstępnych, które użytkownik musi spełnić, zanim będzie można utworzyć dodatków. Dla wygody Google udostępnia metoda courses.checkAddOnCreationEligibility, aby określić, czy użytkownik spełnia te wymagania wstępne. Użytkownik, który spełnia wymagania wstępne, jest nazywany odpowiednim użytkownikiem.

Dodaj kontrolę kwalifikowania się do implementacji trasy tworzenia CourseWork. Następnie przetestuj pole isCreateAttachmentEligible w odpowiedzi. Dla kwalifikujących się wykonaj te kroki, aby utworzyć przypisanie z dodatkiem . W przeciwnym razie utwórz link Materiał. Musisz znać identyfikator zajęć w użytkownik chce utworzyć przypisanie. Zazwyczaj jest to prośba do użytkownika aby wybrać kurs. Dla uproszczenia używamy wpisanej na stałe wartości w argumencie w tym przykładzie.

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.

Tworzenie projektu z załącznikiem dla kwalifikujących się użytkowników

Jeśli użytkownik może tworzyć załączniki dodatków, wykonaj te czynności:

  1. Wyślij żądanie do interfejsu API, aby utworzyć przypisanie courseWork w Google Classroom bez załączników.
  2. Wyodrębnij id nowo utworzonego projektu.
  3. Utwórz nowy obiekt CourseWork AddOnAttachment.
  4. Wyślij prośbę o utworzenie załącznika dodatku w nowo utworzonym 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()
  )

Jeśli użytkownik nie ma uprawnień do tworzenia załączników dodatków, utwórz link Material Design, 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 istniejącego projektu

Dostęp do dowolnej usługi Google Classroom możesz uzyskiwać, modyfikować, oddawać, odzyskiwać i zwracać. element strumienia, który ma co najmniej jeden z załączników dodatku, niezależnie od tego, utworzył(a) element strumienia. Elementy strumienia mogą mieć dowolne wartości z parametrów Announcement i CourseWork projektu lub CourseWorkMaterial.

Aby to zademonstrować, dodasz trasę, aby zmodyfikować dany element strumienia. Użyj tej metoda w celu potwierdzenia, że masz dostęp do utworzonych przez siebie elementów strumienia i możesz je modyfikować przy użyciu interfejsu API i utworzonego przez nauczyciela za pomocą interfejsu Google Classroom.

Dodaj jeszcze jeden link lub przycisk do strony internetowej, na której po raz pierwszy edytowano w tym przewodniku. Powinna otworzyć nową trasę do zmodyfikowania: CourseWork projektu.

Python

Podany przykład Pythona modyfikuje zmodyfikowaną trasę /index 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. To jest w coursework_routes.py.

# 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 podane przykłady są zakodowane na stałe w kursie identyfikatory przypisań. Możesz uzyskać te identyfikatory, wysyłając żądania za pomocą: dane logowania nauczyciela w metodach get i list w courses oraz courseWork. Są one również zwracane w odpowiedzi podczas tworzenia courseWork projektów.

Uruchom serwer, a następnie przejdź na stronę indeksu i zaloguj się jako nauczyciel bez usługi Google Workspace for Education Teaching & Licencja Learning lub Plus. Możesz przełączyć stanu licencji użytkownika z domeny testowej w konsoli administracyjnej. Kliknij Utwórz projekt CourseWork. a następnie otwórz interfejs Google Classroom i sprawdź, czy projekt z atrybutem Utworzono załącznik z materiałem linku. Załącznik powinien zawierać tytuł i adres URL, do której prowadzi link.

Testowe tworzenie przyłącza dodatku

Wróć na stronę indeksu i zaloguj się jako nauczyciel w Google Workspace for Education Teaching &amp; Licencja Learning lub Plus. Kliknij Create a CourseWork Assignment (Utwórz projekt CourseWork) a następnie otwórz interfejs Google Classroom i sprawdź, czy projekt utworzono załącznik dodatku. Załącznik powinien zawierać nazwę Twojego aplikacji dodatku i tytułu określonego w kodzie.

Zmiana przypisania testowego

Wróć na stronę indeksu i upewnij się, że jesteś zalogowany(-a) jako nauczyciel. dzięki narzędziu Teaching & Licencja Learning lub Plus. Kliknij Zmień zadanie Projekt, a następnie wróć do interfejsu Google Classroom i sprawdź, czy Zmieniono tytuł projektu.

Gratulacje! To już wszystkie instrukcje.