Załączniki typu treści

Oto czwarty przewodnik po dodatkach do Classroom. które zrecenzować w naszym serwisie.

Z tego przewodnika dowiesz się, jak za pomocą interfejsu Google Classroom API utworzyć załączniki. Określasz trasy, dzięki którym użytkownicy będą mogli wyświetlić zawartość załącznika. widoków różnią się w zależności od roli użytkownika w zajęciach. Ten przewodnik obejmuje załączniki typu treść, które nie wymagają przesłania przez ucznia.

W ramach tego przewodnika wykonaj następujące czynności:

• Pobierz następujące dodatkowe parametry zapytania i użyj ich:
  • addOnToken: token autoryzacji przekazywany do wykrywania załączników Wyświetl.
  • itemId: unikalny identyfikator obiektu CourseWork, CourseWorkMaterial lub Ogłoszenie, do którego został dołączony załącznik.
  • itemType: „courseWork” lub „courseWorkMaterials” lub „ogłoszenie”.
  • courseId: unikalny identyfikator zajęć Google Classroom w który jest tworzony.
  • attachmentId: unikalny identyfikator przypisany przez Google Classroom do załącznika dodatku po utworzeniu.
• Zaimplementuj trwałą pamięć masową dla załączników typu treści.
• Podawaj trasy umożliwiające tworzenie załączników oraz wyświetlanie Elementy iframe widoku ucznia.
• Wyślij te żądania do interfejsu API dodatków Google Classroom:
  • Utwórz nowy załącznik.
  • Pobierz kontekst dodatku, który określa, czy zalogowany użytkownik ucznia lub nauczyciela.

Gdy skończysz, możesz tworzyć załączniki typu treści w projektach, interfejsu Google Classroom po zalogowaniu się jako nauczyciel. Nauczyciele i uczniowie w: i zajęcia mogą wyświetlać te treści.

Włączanie interfejsu Classroom API

Wywołuj interfejs Classroom API, zaczynając od tego kroku. Interfejs API musi należy włączyć w projekcie Google Cloud, aby móc wykonywać jego wywołania. Nawigacja do wpisu biblioteki interfejsu Google Classroom API i wybierz Włącz.

Obsługa parametrów zapytania dotyczących wyświetlania załączników

Jak wspomnieliśmy wcześniej, Google Classroom przekazuje parametry zapytania, gdy wczytywanie widoku wykrywania załączników w elemencie iframe:

• courseId: identyfikator bieżących zajęć w Classroom.
• itemId: unikalny identyfikator obiektu CourseWork, CourseWorkMaterial lub Ogłoszenie, do którego jest dołączony załącznik.
• itemType: „courseWork” lub „courseWorkMaterials” lub „ogłoszenie”.
• addOnToken: token używany do autoryzowania określonych Działania dodatkowe Classroom.
• login_hint: identyfikator Google bieżącego użytkownika.

Ten przewodnik dotyczy courseId, itemId, itemType i addOnToken. Zachowuj i przekazuj je podczas wywoływania interfejsu API Classroom.

Tak jak w poprzednim kroku, zapisz przekazane wartości parametrów zapytania w naszej sesji. To ważne, gdy widok Odkrywanie załączników jest ponieważ jest to jedyna możliwość, i przekazują te parametry zapytania.

# Retrieve the itemId, courseId, and addOnToken query parameters.
if flask.request.args.get("itemId"):
    flask.session["itemId"] = flask.request.args.get("itemId")
if flask.request.args.get("itemType"):
    flask.session["itemType"] = flask.request.args.get("itemType")
if flask.request.args.get("courseId"):
    flask.session["courseId"] = flask.request.args.get("courseId")
if flask.request.args.get("addOnToken"):
    flask.session["addOnToken"] = flask.request.args.get("addOnToken")

Dodaj pamięć trwałą na załączniki typu treści

Musisz mieć lokalny rejestr wszystkich utworzonych załączników. Pozwoli Ci to wyszukać wybranych przez nauczyciela za pomocą identyfikatorów dostarczonych przez Classroom.

Skonfiguruj schemat bazy danych dla instancji Attachment. Nasz przykład pokazuje załączniki z obrazem i podpisem. Pole Attachment zawiera następujące atrybuty:

• attachment_id: unikalny identyfikator załącznika. Przydzielone przez Classroom i zwracane w odpowiedzi podczas tworzenia załącznik.
• image_filename: lokalna nazwa pliku obrazu do wyświetlenia.
• image_caption: podpis wyświetlany z obrazem.

class Attachment(db.Model):
    # The attachmentId is the unique identifier for the attachment.
    attachment_id = db.Column(db.String(120), primary_key=True)

    # The image filename to store.
    image_filename = db.Column(db.String(120))

    # The image caption to store.
    image_caption = db.Column(db.String(120))

Skonfiguruj nowe trasy

Rozpocznij ten przewodnik od konfiguracji nowych stron w naszej aplikacji. Umożliwiają one użytkownikom tworzenie i wyświetlanie treści za pomocą naszego dodatku.

Dodaj trasy tworzenia załączników

Aby nauczyciel mógł wybrać treść i rozwiązać problem z tworzeniem załączników, musisz mieć strony żądań. Aby wyświetlić opcje treści, zaimplementuj trasę /attachment-options który nauczyciel może wybrać. Potrzebne będą również szablony do wyboru treści strony potwierdzenia utworzenia. Nasze podane przykłady zawierają szablony przeznaczone do następujących celów: a także wyświetlać żądania i odpowiedzi Interfejs API Classroom.

Pamiętaj, że możesz również zmodyfikować istniejący widok wykrywania załączników strony docelowej, aby wyświetlić opcje treści, zamiast tworzyć nowy Strona /attachment-options. Zalecamy utworzenie nowej strony do celów w ramach tego ćwiczenia, aby zachować działanie SSO wdrożone w ciągu sekundy krok instrukcji, takiego jak unieważnienie uprawnień aplikacji. Powinno to udowodnić, przydatne podczas tworzenia i testowania dodatku.

Nauczyciel może wybrać z małego zestawu grafik z podpisami przykład. Przygotowaliśmy cztery zdjęcia znanych miejsc, z podpisami pochodzi z nazw plików.

@app.route("/attachment-options", methods=["GET", "POST"])
def attachment_options():
    """
    Render the attachment options page from the "attachment-options.html"
    template.

    This page displays a grid of images that the user can select using
    checkboxes.
    """

    # A list of the filenames in the static/images directory.
    image_filenames = os.listdir(os.path.join(app.static_folder, "images"))

    # The image_list_form_builder method creates a form that displays a grid
    # of images, checkboxes, and captions with a Submit button. All images
    # passed in image_filenames will be shown, and the captions will be the
    # title-cased filenames.

    # The form must be built dynamically due to limitations in WTForms. The
    # image_list_form_builder method therefore also returns a list of
    # attribute names in the form, which will be used by the HTML template
    # to properly render the form.
    form, var_names = image_list_form_builder(image_filenames)

    # If the form was submitted, validate the input and create the attachments.
    if form.validate_on_submit():

        # Build a dictionary that maps image filenames to captions.
        # There will be one dictionary entry per selected item in the form.
        filename_caption_pairs = construct_filename_caption_dictionary_list(
            form)

        # Check that the user selected at least one image, then proceed to
        # make requests to the Classroom API.
        if len(filename_caption_pairs) > 0:
            return create_attachments(filename_caption_pairs)
        else:
            return flask.render_template(
                "create-attachment.html",
                message="You didn't select any images.",
                form=form,
                var_names=var_names)

    return flask.render_template(
        "attachment-options.html",
        message=("You've reached the attachment options page. "
                "Select one or more images and click 'Create Attachment'."),
        form=form,
        var_names=var_names,
    )

Prośby o utworzenie załączników dotyczących problemu

Gdy wiesz już, jakie materiały nauczyciel chciałby dołączyć, wysyłania próśb o przesłanie do interfejsu Classroom API próśb o utworzenie załączników w naszym projektu. Zapisz szczegóły załącznika w bazie danych po otrzymaniu odpowiedź z interfejsu Classroom API.

Zacznij od pobrania instancji usługi Classroom:

def create_attachments(filename_caption_pairs):
    """
    Create attachments and show an acknowledgement page.

    Args:
        filename_caption_pairs: A dictionary that maps image filenames to
            captions.
    """
    # Get the Google Classroom service.
    classroom_service = googleapiclient.discovery.build(
        serviceName="classroom",
        version="v1",
        credentials=credentials)

Wyślij prośbę CREATE do: courses.courseWork.addOnAttachments punktu końcowego. Dla każdego zdjęcia wybranego przez nauczyciela najpierw utwórz Obiekt AddOnAttachment:

# Create a new attachment for each image that was selected.
attachment_count = 0
for key, value in filename_caption_pairs.items():
    attachment_count += 1

    # Create a dictionary with values for the AddOnAttachment object fields.
    attachment = {
        # Specifies the route for a teacher user.
        "teacherViewUri": {
            "uri":
                flask.url_for(
                    "load_content_attachment", _scheme='https', _external=True),
        },
        # Specifies the route for a student user.
        "studentViewUri": {
            "uri":
                flask.url_for(
                    "load_content_attachment", _scheme='https', _external=True)
        },
        # The title of the attachment.
        "title": f"Attachment {attachment_count}",
    }

Minimalna liczba pól teacherViewUri, studentViewUri i title musi wynosić podane dla każdego załącznika. teacherViewUri i studentViewUri wskazują adresy URL, które są wczytywane po otwarciu załącznika przez odpowiedniego typu użytkownika.

Wyślij obiekt AddOnAttachment w treści żądania do odpowiedniego Punkt końcowy addOnAttachments. Podaj courseId, itemId, itemType i addOnToken identyfikatorów z każdym żądaniem.

# Use the itemType to determine which stream item type the teacher created
match flask.session["itemType"]:
    case "announcements":
        parent = classroom_service.courses().announcements()
    case "courseWorkMaterials":
        parent = classroom_service.courses().courseWorkMaterials()
    case _:
        parent = classroom_service.courses().courseWork()

# Issue a request to create the attachment.
resp = parent.addOnAttachments().create(
    courseId=flask.session["courseId"],
    itemId=flask.session["itemId"],
    addOnToken=flask.session["addOnToken"],
    body=attachment).execute()

Utwórz wpis dla tego przyłącza w lokalnej bazie danych, aby móc go później wczytuj właściwe treści. Classroom zwraca unikalną wartość id w odpowiedzi na prośbę o utworzenie, użyj więc go jako klucza podstawowego w bazie danych. Pamiętaj też, że Classroom przekazuje attachmentId za pomocą parametru zapytania po otwarciu widoków Nauczyciel i Uczniowie:

# Store the value by id.
new_attachment = Attachment(
    # The new attachment's unique ID, returned in the CREATE response.
    attachment_id=resp.get("id"),
    image_filename=key,
    image_caption=value)
db.session.add(new_attachment)
db.session.commit()

Rozważ przekierowanie użytkownika na stronę potwierdzenia z potwierdzeniem, że o utworzeniu załączników.

Zezwalanie na załączniki z dodatku

Teraz jest dobry moment, aby dodać odpowiednie adresy do dozwolonego załącznika Pole Prefiksy URI w konfiguracji aplikacji pakietu SDK Google Workspace Marketplace stronę. Dodatek może tworzyć załączniki tylko z jednego z prefiksów URI wymienionych na tej stronie. Jest to zabezpieczenie, które ma zmniejszyć prawdopodobieństwo ataków typu „man in the middle”.

Najprostszym sposobem jest podanie w tym polu domeny najwyższego poziomu, przykładowy https://example.com. https://localhost:<your port number>/ będzie działa, jeśli używasz komputera lokalnego jako serwera WWW.

Dodawanie tras w widoku nauczyciela i ucznia

W których może być załadowany dodatek do Google Classroom, znajdują się 4 elementy iframe. Masz tylko trasy, które obsługują element iframe widoku wykrywania załączników, więc jak daleko. Następnie dodaj trasy, które będą wyświetlać elementy iframe widoku nauczyciela i ucznia.

Do wyświetlania podglądu ucznia jest wymagany element iframe Widok nauczyciela. ale opcjonalnie mogą podać dodatkowe informacje lub informacje o zmianach funkcje zabezpieczeń.

Widok ucznia to strona wyświetlana każdemu uczniowi po jego otwarciu załączniku dodatku.

Na potrzeby tego ćwiczenia utwórz pojedynczy /load-content-attachment , która obsługuje widok nauczyciela i ucznia. Korzystanie z interfejsu Classroom API które pozwalają ustalić, czy użytkownik jest nauczycielem czy uczniem, .

@app.route("/load-content-attachment")
def load_content_attachment():
    """
    Load the attachment for the user's role."""

    # Since this is a landing page for the Teacher and Student View iframes, we
    # need to preserve the incoming query parameters.
    if flask.request.args.get("itemId"):
        flask.session["itemId"] = flask.request.args.get("itemId")
    if flask.request.args.get("itemType"):
        flask.session["itemType"] = flask.request.args.get("itemType")
    if flask.request.args.get("courseId"):
        flask.session["courseId"] = flask.request.args.get("courseId")
    if flask.request.args.get("attachmentId"):
        flask.session["attachmentId"] = flask.request.args.get("attachmentId")

Pamiętaj, że na tym etapie musisz także uwierzytelnić użytkownika. Ty powinien też obsługiwać w tym miejscu parametr zapytania login_hint i kierować użytkownika do lub proces autoryzacji. Zapoznaj się ze wskazówkami dotyczącymi logowania, które omówiliśmy. w poprzednich instrukcjach, aby dowiedzieć się więcej o tym procesie.

Następnie wyślij żądanie do punktu końcowego getAddOnContext, który pasuje do elementu typu.

# Create an instance of the Classroom service.
classroom_service = googleapiclient.discovery.build(
    serviceName="classroom"
    version="v1",
    credentials=credentials)

# Use the itemType to determine which stream item type the teacher created
match flask.session["itemType"]:
    case "announcements":
        parent = classroom_service.courses().announcements()
    case "courseWorkMaterials":
        parent = classroom_service.courses().courseWorkMaterials()
    case _:
        parent = classroom_service.courses().courseWork()

addon_context_response = parent.getAddOnContext(
    courseId=flask.session["courseId"],
    itemId=flask.session["itemId"]).execute()

Ta metoda zwraca informacje o roli bieżącego użytkownika w zajęciach. zmieniać widok wyświetlany użytkownikowi w zależności od jego roli. Dokładnie jeden z Pola studentContext i teacherContext są wypełnione w odpowiedzi . Sprawdź je, aby dowiedzieć się, jak zwracać się do użytkownika.

W każdym przypadku użyj wartości parametru zapytania attachmentId, by dowiedzieć się, co do pobrania z naszej bazy danych. Ten parametr zapytania jest podawany, gdy: otwierając identyfikatory URI widoku nauczyciela lub ucznia.

# Determine which view we are in by testing the returned context type.
user_context = "student" if addon_context_response.get(
    "studentContext") else "teacher"

# Look up the attachment in the database.
attachment = Attachment.query.get(flask.session["attachmentId"])

# Set the text for the next page depending on the user's role.
message_str = f"I see that you're a {user_context}! "
message_str += (
    f"I've loaded the attachment with ID {attachment.attachment_id}. "
    if user_context == "teacher" else
    "Please enjoy this image of a famous landmark!")

# Show the content with the customized message text.
return flask.render_template(
    "show-content-attachment.html",
    message=message_str,
    image_filename=attachment.image_filename,
    image_caption=attachment.image_caption,
    responses=response_strings)

Testowanie dodatku

Aby przetestować tworzenie załączników, wykonaj te czynności:

• Zaloguj się w [Google Classroom] jako jedno ze Nauczyciele: użytkownicy testowi.
• Otwórz kartę Zadania i utwórz nowy projekt.
• Kliknij przycisk Dodatki pod obszarem tekstowym, a następnie wybierz dodatek. Element iframe otworzy się, a dodatek wczyta identyfikator URI konfiguracji załącznika, możesz je określić na stronie Konfiguracja aplikacji pakietu SDK Google Workspace Marketplace.
• Wybierz treść, którą chcesz dołączyć do projektu.
• Po zakończeniu procesu tworzenia załącznika zamknij element iframe.

W interfejsie tworzenia projektu w Google powinna wyświetlić się karta załącznika Google Classroom. Kliknij kartę, aby otworzyć element iframe widoku nauczyciela, i potwierdź pojawi się właściwy załącznik. Kliknij przycisk Przypisz.

Aby przetestować działanie interfejsu ucznia, wykonaj te czynności:

• Następnie zaloguj się w Classroom jako użytkownik testowy w tym samym jako użytkownik testowy.
• Znajdź projekt testowy na karcie Zadania.
• Rozwiń projekt i kliknij kartę załącznika, aby otworzyć widok ucznia. iframe.

Sprawdź, czy uczniowi wyświetla się właściwy załącznik.

Gratulacje! Możesz już przejść do następnego kroku: tworzenia załączniki typu aktywności.