Allegati esterni e consegna

Questo è il settimo tutorial della serie di tutorial sui componenti aggiuntivi di Classroom.

In questo tutorial, aggiungerai un comportamento a un'applicazione web per creare allegati di componenti aggiuntivi al di fuori di Google Classroom. Utilizza questo comportamento per consentire agli utenti di creare allegati di componenti aggiuntivi dal tuo prodotto o sito web esistente. Si tratta anche di un'ottima aggiunta a un'integrazione CourseWork, perché indirizzi il traffico esistente all'esperienza utente migliorata offerta dal tuo componente aggiuntivo senza modificarne il flusso. La procedura suggerita è presentata nella pagina della guida Creare allegati al di fuori di Classroom.

Aggiungerai anche un comportamento al tuo componente aggiuntivo per modificare un compito con allegati di componenti aggiuntivi a livello di programmazione. Puoi modificare qualsiasi compito che abbia uno degli allegati di componenti aggiuntivi, indipendentemente da chi l'ha creato. Questa funzionalità è particolarmente utile per consegnare i compiti dopo che uno studente ha completato un'attività, segnalando all'insegnante che le attività assegnate sono state completate e che il lavoro dello studente è pronto per la revisione.

Estenderai la versione finale del componente aggiuntivo che supporta gli allegati di tipo di contenuto o di tipo di attività. In questa guida viene utilizzato l'allegato di tipo di contenuto.

Aggiungere l'ambito OAuth di gestione dei compiti

Assicurati che la tua applicazione richieda i seguenti ambiti:

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

L'ambito classroom.coursework.students non era necessario in precedenza e viene utilizzato per creare o modificare i compiti CourseWork. Aggiungi questo ambito agli elenchi di ambiti nell'SDK di Google Workspace Marketplace , nella schermata per il consenso OAuthe nel codice del server del tuo progetto 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",
  ]

Creare un compito in Classroom

Aggiungere pulsanti a una pagina web senza iframe

Il flusso descritto in questo tutorial consente a un utente di creare compiti e allegati di Google Classroom da un prodotto non Google. In pratica, si tratta probabilmente del tuo sito web o della tua applicazione esistente. Per questo esempio, devi creare una pagina web fittizia che funga da sito esterno. Ti serve un pulsante o un link che, quando viene selezionato, apre una nuova route che esegue il flusso suggerito CourseWorkper creare un nuovo compito.

Dovrai anche aggiungere un pulsante o un link per consentire all'utente di accedere , se non ne hai già uno. Per effettuare le successive richieste API, avrai bisogno delle credenziali utente, quindi devi completare l'handshake OAuth 2.0. Per indicazioni specifiche, consulta il tutorial di accesso.

Python

L'esempio Python fornito modifica la route /index introdotta nel primo passaggio del tutorial.

<!-- /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>

Aggiungi un modello HTML per rappresentare una destinazione nel tuo sito web. Questa pagina rappresenterà i contenuti che verranno allegati al compito 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>

Crea un nuovo file di modulo Python per gestire le route correlate a CourseWork. Nel nostro esempio fornito, si tratta di coursework_routes.py. Aggiungi le tre route seguenti. Tieni presente che alcuni contenuti verranno inseriti in un secondo momento.

# /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")

Verificare l'idoneità di un utente alla creazione di allegati

Esistono diversi prerequisiti che un utente deve soddisfare prima di poter creare allegati di componenti aggiuntivi per suo conto. Per comodità, Google fornisce il userProfiles.checkUserCapability metodo per determinare se un utente soddisfa questi prerequisiti. Un utente che soddisfa i prerequisiti viene definito idoneo.

Aggiungi il controllo di idoneità all'implementazione della route di creazione di CourseWork. Poi testa il campo allowed nella risposta. Per gli utenti idonei, segui la logica per creare un compito con l'allegato del componente aggiuntivo. In caso contrario, crea un Materiale con link. Dovrai conoscere l'ID del corso in cui l'utente vuole creare un compito. In genere, chiedi all'utente di specificare quale corso utilizzare. Per semplicità, in questo esempio utilizziamo un valore hardcoded.

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 ...

  # Check whether the user can create add-on attachments.
  eligibility_response = (
      classroom_service.userProfiles()
      .checkUserCapability(
        userId="me",
        capability="CREATE_ADD_ON_ATTACHMENT",
        # The previewVersion is necessary while the method is available in the
        # Workspace Developer Preview Program.
        previewVersion="V1_20240930_PREVIEW",
      ).execute()
  )
  is_create_attachment_eligible = eligibility_response.get("allowed")

  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.

Creare un compito con l'allegato del componente aggiuntivo per gli utenti idonei

Se l'utente è idoneo a creare allegati di componenti aggiuntivi:

  1. Invia una richiesta API per creare un compito courseWork in Google Classroom senza allegati.
  2. Estrai l'id del compito appena creato.
  3. Crea un nuovo CourseWork AddOnAttachment.
  4. Invia una richiesta per creare un allegato di componente aggiuntivo nel compito appena creato in Google Classroom.

Python

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

# /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()
  )

Se l'utente non è idoneo a creare allegati di componenti aggiuntivi, crea invece un materiale con link procedendo come segue:

Python

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

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()
    )

Modificare un compito già creato

Puoi accedere, modificare, consegnare, recuperare o restituire qualsiasi elemento dello stream di Google Classroom che abbia almeno uno degli allegati di componenti aggiuntivi, indipendentemente da chi l'ha creato. Gli elementi dello stream sono qualsiasi Announcement, CourseWork compito o CourseWorkMaterial.

Per dimostrarlo, aggiungerai una route per modificare un determinato elemento dello stream. Utilizza questo metodo per verificare di poter accedere e modificare gli elementi dello stream creati da te utilizzando l'API e creati da un insegnante tramite l'interfaccia utente di Google Classroom.

Aggiungi un altro link o pulsante alla pagina web che hai modificato per la prima volta in questo tutorial. Dovrebbe aprire una nuova route per modificare un compito CourseWork.

Python

L'esempio Python fornito modifica la route /index modificata in precedenza in questo tutorial.

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

Crea una nuova route per gestire le route correlate a CourseWork. Nel nostro esempio fornito, si trova nel file 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()
)

Testare il componente aggiuntivo

Per semplicità, gli esempi forniti utilizzano identificatori di corsi e compiti hardcoded. Puoi ottenere questi identificatori effettuando richieste con le credenziali dell'insegnante ai metodi get e list delle risorse courses e courseWork. Vengono restituiti anche nella risposta quando crei compiti courseWork.

Esegui il server, poi vai alla pagina dell'indice e accedi come utente insegnante senza una licenza Google Workspace for Education Teaching &Learning o Plus. Puoi attivare o disattivare lo stato della licenza di un utente dalla console di amministrazione del dominio di test.Fai clic sul pulsante Crea un compito CourseWork, poi apri l'interfaccia utente di Google Classroom e verifica che sia stato creato un compito con un allegato di materiale con link. L'allegato deve mostrare il titolo della pagina web collegata e un URL.

Testare la creazione di allegati di componenti aggiuntivi

Torna alla pagina dell'indice e accedi come utente insegnante con una licenza Google Workspace for Education Teaching & Learning o Plus. Fai clic sul pulsante Crea un compito CourseWork, poi apri l'interfaccia utente di Google Classroom e verifica che sia stato creato un compito con un allegato di componente aggiuntivo. L'allegato deve mostrare il nome dell'applicazione del componente aggiuntivo e il titolo specificato nel codice.

Testare la modifica dei compiti

Torna alla pagina dell'indice e assicurati di aver eseguito l'accesso come utente insegnante con una licenza Teaching &Learning o Plus. Fai clic sul pulsante Modifica un compito CourseWork, poi torna all'interfaccia utente di Google Classroom e verifica che il titolo del compito sia stato modificato.

Complimenti! Hai completato la serie di tutorial.