Administrar Trabajo en clase

Classroom tiene cinco tipos de Trabajo en clase: Tareas, Tareas, Preguntas (respuesta breve y opción múltiple) y Materiales. Actualmente, la API de Classroom permite que los desarrolladores lean y escriban tres tipos de tareas: tareas, preguntas y materiales.

Para acceder a esta funcionalidad, puedes usar el recurso WorkWork, que representa una tarea o una pregunta asignada a los alumnos de un curso en particular, incluidos los materiales y los detalles adicionales, como la fecha límite o la puntuación máxima.

Además del recurso CourseWork, puedes administrar las tareas completadas con el recurso StudentSubmission. En las siguientes secciones, se describen con más detalle.

Crear tareas

Las tareas solo se pueden crear en nombre del profesor del curso y, si intentas crear tareas en un curso en nombre de un alumno, se generará un error 403 PERMISSION_DENIED. Del mismo modo, los administradores de dominio tampoco pueden crear tareas para los cursos que no enseñan y tratar de hacerlo mediante la API también dará como resultado un error 403 PERMISSION_DENIED.

Cuando creas asignaciones, puedes adjuntar vínculos como materials, que se muestra en el siguiente código de muestra:

Python

classroom/snippets/classroom_create_coursework.py
from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_create_coursework(course_id):

    """
    Creates the coursework the user has access to.
    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """

    creds, _ = google.auth.default()
    # pylint: disable=maybe-no-member

    try:
        service = build('classroom', 'v1', credentials=creds)
        coursework = {
            'title': 'Ant colonies',
            'description': '''Read the article about ant colonies
                              and complete the quiz.''',
            'materials': [
                {'link': {'url': 'http://example.com/ant-colonies'}},
                {'link': {'url': 'http://example.com/ant-quiz'}}
            ],
            'workType': 'ASSIGNMENT',
            'state': 'PUBLISHED',
        }
        coursework = service.courses().courseWork().create(
            courseId=course_id, body=coursework).execute()
        print(f"Assignment created with ID {coursework.get('id')}")
        return coursework

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error


if __name__ == '__main__':
    # Put the course_id of course whose coursework needs to be created,
    # the user has access to.
    classroom_create_coursework(453686957652)

El resultado incluye un identificador asignado por el servidor que se puede usar para hacer referencia a la asignación en otras solicitudes a la API.

Para incluir materiales vinculados en una tarea creada a través de la API de Classroom, usa un recurso de vínculo que especifique la URL de destino. Classroom recupera automáticamente el título y la imagen en miniatura. La API de Classroom también admite de forma nativa los materiales de Drive y YouTube, que se pueden incluir de forma similar con un recurso DriveFile o un recurso de video de YouTube.

Para especificar una fecha límite, configura los campos dueDate y dueTime en la hora UTC correspondiente. La fecha límite debe ser futura.

Recuperar tareas y preguntas

Puedes recuperar los deberes y las preguntas para los alumnos y los profesores del curso correspondiente o lo haga un administrador de dominio. Para recuperar una tarea o pregunta específica, usa courses.courseWork.get. Para recuperar todas las tareas o preguntas (que pueden coincidir con algunos criterios de forma opcional), usacourses.courseWork.list.

El alcance requerido depende de la función que tenga el usuario solicitante en el curso. Si el usuario es alumno, usa uno de los siguientes alcances:

  • https://www.googleapis.com/auth/classroom.coursework.me.readonly
  • https://www.googleapis.com/auth/classroom.coursework.me

Si el usuario es un profesor o un administrador de dominio, usa uno de los siguientes alcances:

  • https://www.googleapis.com/auth/classroom.coursework.students.readonly
  • https://www.googleapis.com/auth/classroom.coursework.students

Tener permiso para recuperar una tarea o pregunta no implica acceder a materiales ni metadatos de materiales. En la práctica, esto significa que es posible que el administrador no vea el título de un archivo de Drive adjunto si no es miembro del curso. Si deseas permitir que los administradores accedan a los archivos del usuario, consulta la guía de delegación de todo el dominio.

Cómo administrar las respuestas de los alumnos

Un recurso StudentSubmission representa el trabajo realizado y la calificación de un alumno para una tarea o pregunta. Se crea un recurso StudentSubmission de forma implícita para cada alumno cuando se crea una pregunta o tarea nueva.

En las siguientes secciones, se explican las acciones comunes que administran las respuestas de los alumnos.

Recuperar las respuestas de los alumnos

Los alumnos pueden recuperar sus propias entregas, los profesores pueden recuperar las entregas de todos los alumnos de sus cursos y los administradores de dominio pueden recuperar todas las entregas de todos los alumnos de su dominio. A cada entrega de alumno se le asigna un identificador; si lo conoces, usa courses.courseWork.studentSubmissions.get para recuperarlo.

Usa los cursos.courseWork.studentSubmissions.list para obtener StudentSubmission que coincida con algunos criterios, como se muestra en el siguiente ejemplo:

Python

classroom/snippets/classroom_list_submissions.py
from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_list_submissions(course_id, coursework_id):
    """
    Creates the courses the user has access to.
    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """

    creds, _ = google.auth.default()
    # pylint: disable=maybe-no-member
    submissions = []
    page_token = None

    try:
        service = build('classroom', 'v1', credentials=creds)
        while True:
            coursework = service.courses().courseWork()
            response = coursework.studentSubmissions().list(
                pageToken=page_token,
                courseId=course_id,
                courseWorkId=coursework_id,
                pageSize=10).execute()
            submissions.extend(response.get('studentSubmissions', []))
            page_token = response.get('nextPageToken', None)
            if not page_token:
                break

        if not submissions:
            print('No student submissions found.')

        print('Student Submissions:')
        for submission in submissions:
            print(f"Submitted at:"
                  f"{(submission.get('id'), submission.get('creationTime'))}")

    except HttpError as error:
        print(f"An error occurred: {error}")
        submissions = None
    return submissions


if __name__ == '__main__':
    # Put the course_id and coursework_id of course whose list needs to be
    # submitted.
    classroom_list_submissions(453686957652, 466086979658)

Para recuperar las entregas de los alumnos que pertenecen a un estudiante en particular, especifica el parámetro userId, como se muestra en el siguiente ejemplo:

Python

classroom/snippets/classroom_list_student_submissions.py
from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def classroom_list_student_submissions(course_id, coursework_id, user_id):
    """
    Creates the courses the user has access to.
    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """

    creds, _ = google.auth.default()
    # pylint: disable=maybe-no-member
    submissions = []
    page_token = None

    try:
        service = build('classroom', 'v1', credentials=creds)
        while True:
            coursework = service.courses().courseWork()
            response = coursework.studentSubmissions().list(
                pageToken=page_token,
                courseId=course_id,
                courseWorkId=coursework_id,
                userId=user_id).execute()
            submissions.extend(response.get('studentSubmissions', []))
            page_token = response.get('nextPageToken', None)
            if not page_token:
                break

        if not submissions:
            print('No student submissions found.')

        print('Student Submissions:')
        for submission in submissions:
            print(f"Submitted at:"
                  f"{(submission.get('id'), submission.get('creationTime'))}")

    except HttpError as error:
        print(f"An error occurred: {error}")
    return submissions


if __name__ == '__main__':
    # Put the course_id, coursework_id and user_id of course whose list needs
    # to be submitted.
    classroom_list_student_submissions(453686957652, 466086979658, "me")

Los alumnos se identifican por el ID único o la dirección de correo electrónico del usuario, como lo muestra el SDK de Admin de Google. El usuario actual también puede hacer referencia a su propio ID con la abreviatura "me".

También es posible obtener las entregas de los alumnos para todas las tareas de un curso. Para hacerlo, usa el literal "-" como cursoWorkId, como se muestra en el siguiente ejemplo:

Python

service.courses().courseWork().studentSubmissions().list(
    courseId=<course ID or alias>,
    courseWorkId='-',
    userId=<user ID>).execute()

El alcance requerido depende de la función que tenga el usuario solicitante en el curso. Usa el siguiente alcance si el usuario es un profesor o un administrador de dominio:

  • https://www.googleapis.com/auth/classroom.coursework.students.readonly
  • https://www.googleapis.com/auth/classroom.coursework.students

Usa el siguiente alcance si el usuario es alumno:

  • https://www.googleapis.com/auth/classroom.coursework.me.readonly
  • https://www.googleapis.com/auth/classroom.coursework.me

Tener permiso para recuperar la entrega de un alumno no implica el permiso para acceder a los archivos adjuntos o a los metadatos de los archivos adjuntos. En la práctica, esto significa que un administrador puede no ver el título de un archivo de Drive adjunto si no es miembro del curso. Si deseas permitir que los administradores accedan a los archivos de los usuarios, consulta la guía de delegación de todo el dominio.

Cómo agregar archivos adjuntos a una respuesta de un alumno

Para adjuntar vínculos a la entrega de un alumno, puedes adjuntar un recurso de vínculo, archivo de Drive o video de YouTube. Esto se lleva a cabo concourses.courseWork.studentSubmissions.modifyAttachments, como se muestra en el siguiente ejemplo:

Python

classroom/snippets/classroom_add_attachment.py

def classroom_add_attachment(course_id, coursework_id, submission_id):
    """
    Adds attachment to existing course with specific course_id.
    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """
    creds, _ = google.auth.default()
    # pylint: disable=maybe-no-member
    request = {
        'addAttachments': [
            {'link': {'url': 'http://example.com/quiz-results'}},
            {'link': {'url': 'http://example.com/quiz-reading'}}
        ]
    }

    try:
        service = build('classroom', 'v1', credentials=creds)
        while True:
            coursework = service.courses().courseWork()
            coursework.studentSubmissions().modifyAttachments(
                courseId=course_id,
                courseWorkId=coursework_id,
                id=submission_id,
                body=request).execute()

    except HttpError as error:
        print(f"An error occurred: {error}")


if __name__ == '__main__':
    # Put the course_id, coursework_id and submission_id of course in which
    # attachment needs to be added.
    classroom_add_attachment('course_id', 'coursework_id', "me")

La URL de destino define un adjunto de vínculo. Classroom recuperará automáticamente el título y la imagen en miniatura. Puedes obtener más información sobre los otros materiales en sus respectivas páginas de referencia.

Un profesor del curso o el alumno propietario de la entrega correspondiente puede crear los materiales, pero solo para los alumnos que tienen una courseWorkType de "ASSIGNMENT".

El alcance requerido depende de la función que tenga el usuario solicitante en el curso. Usa el siguiente alcance si el usuario es un profesor:

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

Usa el siguiente alcance si el usuario es alumno:

  • https://www.googleapis.com/auth/classroom.coursework.me

Cómo administrar el estado de respuesta de los alumnos

Una respuesta de un alumno puede entregarse, entregarse o devolverse. El campo de estado de StudentSubmission indica el estado actual. Para cambiar el estado, llama a uno de los siguientes métodos:

Todos estos métodos toman un cuerpo vacío. Ejemplo:

Python

service.courses().courseWork().studentSubmission().turnIn(
    courseId=<course ID or alias>,
    courseWorkId=<courseWork ID>,
    id=<studentSubmission ID>,
    body={}).execute()

Solo el alumno que posee una StudentSubmission puede entregarla o reclamarla. Solo se puede reclamar una entrega entregada. Los profesores del curso solo pueden mostrar una StudentSubmission que esté en el estado entregado.

Califica las respuestas de los alumnos

El recurso StudentSubmission tiene dos campos para almacenar las calificaciones: assignedGrade, que es la calificación que se les informa a los alumnos, y draftGrade, que es una calificación tentativa visible solo para los profesores. Estos campos se actualizan mediante courses.courseWork.studentSubmissions.patch con una máscara de campo que contiene los campos adecuados, como se muestra en el siguiente ejemplo.

Python

studentSubmission = {
  'assignedGrade': 99,
  'draftGrade': 80
}
service.courses().courseWork().studentSubmissions().patch(
    courseId=<course ID or alias>,
    courseWorkId=<courseWork ID>,
    id=<studentSubmission ID>,
    updateMask='assignedGrade,draftGrade',
    body=studentSubmission).execute()

Cuando trabajan con la IU de Classroom, los profesores no pueden asignar una calificación hasta que la guardan por primera vez. Luego, la calificación asignada se puede devolver a un alumno. Las aplicaciones deben emular este comportamiento. Tu aplicación puede calificar una tarea de un alumno de dos maneras:

  • Asigna solo el draftGrade. Esto es útil, por ejemplo, para permitir que el profesor revise las calificaciones de forma manual antes de finalizarlas. Los alumnos no pueden ver las calificaciones preliminares.

  • Asigna tanto la draftGrade como la assignedGrade para calificar una tarea por completo.