Questa è la settima procedura dettagliata della serie sui componenti aggiuntivi di Classroom.
In questa procedura dettagliata, aggiungerai un comportamento a un'applicazione web per creare allegati di componenti aggiuntivi dall'esterno di Google Classroom. Utilizza questo comportamento per consentire agli utenti di creare allegati di componenti aggiuntivi dal prodotto o dal sito web esistente. Questa
è 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. Il processo suggerito è presentato nella pagina della guida Creare allegati
al di fuori di Classroom.
Puoi inoltre aggiungere un comportamento al componente aggiuntivo per modificare in modo programmatico un'assegnazione con allegati di componenti aggiuntivi. Puoi modificare qualsiasi compito con uno degli allegati del componente aggiuntivo, indipendentemente da chi lo ha creato. Ciò è particolarmente utile per consegnare i compiti dopo che uno studente ha completato un'attività, per segnalare all'insegnante che le attività assegnate sono state completate e che il lavoro dello studente è pronto per la revisione.
Estendi la versione finale del componente aggiuntivo che supporta gli allegati content-type o activity-type. In questa guida viene utilizzato l'allegato content-type.
Aggiungi l'ambito OAuth per la gestione dei compiti
Assicurati che la tua applicazione richieda i seguenti ambiti:
https://www.googleapis.com/auth/classroom.addons.teacherhttps://www.googleapis.com/auth/classroom.addons.studenthttps://www.googleapis.com/auth/classroom.coursework.students
L'ambito classroom.coursework.students non è stato necessario in precedenza e viene
utilizzato per creare o modificare le assegnazioni CourseWork. Aggiungi questo ambito agli elenchi di ambiti nell' SDK di Google Workspace Marketplace del progetto Cloud, nella schermata di consenso OAuth e nel codice del server.
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 non iframe
Il flusso descritto in questa procedura dettagliata 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 simulata che agisca da sito esterno. È necessario un pulsante o un link che, se selezionato, apre un nuovo percorso che esegua il flusso CourseWork suggerito per creare una nuova assegnazione.
Dovrai anche aggiungere un pulsante o un link per consentire all'utente di accedere se non ne hai già uno. Avrai bisogno delle credenziali utente per effettuare le richieste API successive, quindi devono completare l'handshake OAuth 2.0. Per indicazioni specifiche, consulta la procedura di accesso.
Python
L'esempio Python fornito modifica la route /index che è stata introdotta nel primo passaggio della procedura dettagliata.
<!-- /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 relative a CourseWork.
coursework_routes.py nell'esempio fornito. Aggiungi i seguenti
tre percorsi; tieni presente che alcuni dei contenuti verranno completati in seguito.
# /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à alla creazione di componenti aggiuntivi di un utente
Per poter creare allegati di componenti aggiuntivi per suo conto, un utente deve soddisfare diversi prerequisiti. Per comodità, Google fornisce il metodo courses.checkAddOnCreationEligibility per determinare se un utente soddisfa questi prerequisiti. Un utente che soddisfa i prerequisiti è definito utente idoneo.
Aggiungi il controllo di idoneità all'implementazione del percorso di creazione di CourseWork.
Quindi, verifica il campo isCreateAttachmentEligible nella risposta. Per gli utenti idonei, segui la logica per creare un compito con allegato di componenti aggiuntivi. In caso contrario, crea un Materiale del link. Devi conoscere l'ID del corso in cui l'utente vuole creare un compito. Di solito, chiedi all'utente
di specificare quale corso usare. Per semplicità, in questo esempio viene utilizzato
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 ...
# 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.
Creare un compito con allegato di componenti aggiuntivi per gli utenti idonei
Se l'utente è idoneo a creare allegati di componenti aggiuntivi, segui questi passaggi:
- Invia una richiesta API per creare un compito
courseWorkin Google Classroom senza allegati. - Estrai il valore
iddel compito appena creato. - Crea un nuovo CourseWork
AddOnAttachment. - Invia una richiesta per creare un allegato di un componente aggiuntivo nel compito appena creato in 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()
)
Crea un materiale per i link
Se l'utente non è idoneo alla creazione di allegati di componenti aggiuntivi, crea un materiale per i link procedendo nel seguente modo:
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()
)
Modificare un compito già creato
Puoi accedere, modificare, consegnare, rivendicare o restituire qualsiasi elemento di streaming di Google Classroom che contiene almeno uno dei tuoi allegati aggiuntivi, indipendentemente da chi ha creato l'elemento dello stream. Gli elementi dello stream sono dei compiti Announcement, CourseWork o CourseWorkMaterial.
A questo scopo, dovrai aggiungere un percorso per modificare un determinato elemento dello stream. Usa questo metodo per verificare di poter accedere e modificare gli elementi dello stream creati da te con l'API e da un insegnante tramite la UI di Google Classroom.
Aggiungi un altro link o pulsante alla pagina web modificata per la prima volta in
questa procedura dettagliata. Dovrebbe aprire una nuova route per modificare un compito CourseWork.
Python
L'esempio Python fornito modifica la route /index che è stata modificata in precedenza in questa procedura dettagliata.
<!-- /webapp/templates/index.html -->
<a href="modify-coursework-assignment.html">Create a CourseWork Assignment</a>
Crea un nuovo percorso per gestire i percorsi relativi a CourseWork. Si trova nel file coursework_routes.py dell'esempio fornito.
# 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()
)
Testa il componente aggiuntivo
Per semplificare le cose, gli esempi forniti utilizzano identificatori hardcoded di corsi e compiti. Puoi ottenere questi identificatori effettuando richieste con
credenziali dell'insegnante ai metodi get e list delle risorse courses e
courseWork. Vengono restituiti anche nella risposta durante la creazione dei compiti courseWork.
Creazione del materiale del link di prova
Esegui il server, poi vai alla pagina di indice e accedi come utente insegnante senza una licenza Google Workspace for Education Teaching & Learning Upgrade o Plus. Puoi attivare lo stato della licenza di un utente dalla Console di amministrazione del dominio di test.Fai clic sul pulsante Crea un compito CourseWork, quindi apri l'interfaccia utente di Google Classroom e verifica che sia stato creato un compito con allegato materiale del link. L'allegato dovrebbe 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, quindi apri l'interfaccia utente di Google Classroom e verifica che sia stato creato un compito con allegato di un componente aggiuntivo. L'allegato dovrebbe mostrare il nome dell'applicazione del componente aggiuntivo e il titolo specificato nel codice.
Prova modifica dell'assegnazione
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, quindi torna all'interfaccia utente di Google Classroom e verifica che il titolo del compito sia stato modificato.
Complimenti! Hai completato la serie di procedure dettagliate.