Se usó la API de Cloud Translation para traducir esta página.

Administrar el trabajo del curso y las calificaciones

La IU de Classroom admite cinco tipos de Trabajo en clase: Tareas, Tareas de preguntas, Preguntas de respuesta breve, Preguntas de opción múltiple y Materiales. Actualmente, la API de Classroom admite tres de estos tipos, que se conocen como CourseWorkType para la API: Tareas, Preguntas de respuesta corta y Preguntas de opción múltiple.

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

Además del recurso CourseWork, puedes administrar 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 de los profesores del curso. Si intentas crear tareas en nombre de un alumno, se mostrará el error 403 PERMISSION_DENIED. Del mismo modo, los administradores de dominio tampoco pueden crear asignaciones para los cursos que no enseñan, y tratar de hacerlo a través de la API también generará un error 403 PERMISSION_DENIED.

Cuando creas tareas con el método courses.courseWork.create, puedes adjuntar vínculos como materials, como se muestra en el siguiente código de muestra:

Java

classroom/fragmentos/src/main/java/CreateCourseWork.java

Ver en GitHub

CourseWork courseWork = null;
try {
  // Create a link to add as a material on course work.
  Link articleLink =
      new Link()
          .setTitle("SR-71 Blackbird")
          .setUrl("https://www.lockheedmartin.com/en-us/news/features/history/blackbird.html");

  // Create a list of Materials to add to course work.
  List<Material> materials = Arrays.asList(new Material().setLink(articleLink));

  /* Create new CourseWork object with the material attached.
  Set workType to `ASSIGNMENT`. Possible values of workType can be found here:
  https://developers.google.com/classroom/reference/rest/v1/CourseWorkType
  Set state to `PUBLISHED`. Possible values of state can be found here:
  https://developers.google.com/classroom/reference/rest/v1/courses.courseWork#courseworkstate */
  CourseWork content =
      new CourseWork()
          .setTitle("Supersonic aviation")
          .setDescription(
              "Read about how the SR-71 Blackbird, the world’s fastest and "
                  + "highest-flying manned aircraft, was built.")
          .setMaterials(materials)
          .setWorkType("ASSIGNMENT")
          .setState("PUBLISHED");

  courseWork = service.courses().courseWork().create(courseId, content).execute();

  /* Prints the created courseWork. */
  System.out.printf("CourseWork created: %s\n", courseWork.getTitle());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf("The courseId does not exist: %s.\n", courseId);
  } else {
    throw e;
  }
  throw e;
} catch (Exception e) {
  throw e;
}
return courseWork;

Python

classroom/fragmentos/classroom_create_coursework.py

Ver en GitHub

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.

Los campos title y workType son obligatorios. Todos los demás campos son opcionales. Si no se especifica state, se creará un borrador de asignación.

Para incluir materiales vinculados en una tarea creada con 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 de la miniatura. La API de Classroom también admite de forma nativa los materiales de Google Drive y YouTube, que se pueden incluir con un recurso de DriveFile o con un recurso de video de YouTube de manera similar.

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

Recupera tareas y preguntas

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

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

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

Si el usuario es profesor o 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 una pregunta no implica permisos de acceso a materiales o 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 sobre delegación de todo el dominio.

Cómo administrar las respuestas de los alumnos

Un recurso StudentSubmission representa el trabajo 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.

Las entregas de los alumnos solo pueden ser modificadas por el proyecto de la Consola para programadores que creó el recurso CourseWork correspondiente. Esto se suma a verificar que el usuario solicitante tenga los permisos correctos. Cualquier cliente de OAuth2 puede realizar modificaciones en ese proyecto. El campo associatedWithDeveloper indica si el cliente de OAuth2 actual puede modificar un StudentSubmission determinado.

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 del dominio pueden recuperar todas las entregas de todos los alumnos de su dominio. A cada entrega de alumno se le asigna un identificador. Si conoces el identificador, usa courses.courseWork.studentSubmissions.get para recuperarlo.

Usa el método courses.courseWork.studentSubmissions.list para obtener recursos StudentSubmission que coincidan con algunos criterios, como se muestra en el siguiente ejemplo:

Java

classroom/fragmentos/src/main/java/ListSubmissions.java

Ver en GitHub

List<StudentSubmission> studentSubmissions = new ArrayList<>();
String pageToken = null;

try {
  do {
    ListStudentSubmissionsResponse response =
        service
            .courses()
            .courseWork()
            .studentSubmissions()
            .list(courseId, courseWorkId)
            .setPageToken(pageToken)
            .execute();

    /* Ensure that the response is not null before retrieving data from it to avoid errors. */
    if (response.getStudentSubmissions() != null) {
      studentSubmissions.addAll(response.getStudentSubmissions());
      pageToken = response.getNextPageToken();
    }
  } while (pageToken != null);

  if (studentSubmissions.isEmpty()) {
    System.out.println("No student submission found.");
  } else {
    for (StudentSubmission submission : studentSubmissions) {
      System.out.printf(
          "Student id (%s), student submission id (%s)\n",
          submission.getUserId(), submission.getId());
    }
  }
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s) or courseWorkId (%s) does not exist.\n", courseId, courseWorkId);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmissions;

Python

classroom/fragmentos/classroom_list_submissions.py

Ver en GitHub

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)

Recupera los recursos StudentSubmission que pertenecen a un alumno en particular especificando el parámetro userId, como se muestra en el siguiente ejemplo:

Java

classroom/fragmentos/src/main/java/ListStudentSubmissions.java

Ver en GitHub

List<StudentSubmission> studentSubmissions = new ArrayList<>();
String pageToken = null;

try {
  do {
    // Set the userId as a query parameter on the request.
    ListStudentSubmissionsResponse response =
        service
            .courses()
            .courseWork()
            .studentSubmissions()
            .list(courseId, courseWorkId)
            .setPageToken(pageToken)
            .set("userId", userId)
            .execute();

    /* Ensure that the response is not null before retrieving data from it to avoid errors. */
    if (response.getStudentSubmissions() != null) {
      studentSubmissions.addAll(response.getStudentSubmissions());
      pageToken = response.getNextPageToken();
    }
  } while (pageToken != null);

  if (studentSubmissions.isEmpty()) {
    System.out.println("No student submission found.");
  } else {
    for (StudentSubmission submission : studentSubmissions) {
      System.out.printf("Student submission: %s.\n", submission.getId());
    }
  }

Python

classroom/fragmentos/classroom_list_student_submissions.py

Ver en GitHub

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 con 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 mediante la abreviatura "me".

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

Java

service.courses().courseWork().studentSubmissions()
    .list(courseId, "-")
    .set("userId", userId)
    .execute();

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 tiene el usuario solicitante en el curso. Usa el siguiente alcance si el usuario es profesor o administrador de dominio:

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

Usa el siguiente permiso 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 permisos para acceder a los archivos adjuntos o metadatos de los archivos adjuntos. 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 Delegación de todo el dominio.

Agregar archivos adjuntos a la respuesta de un alumno

Para adjuntar vínculos a las entregas de los alumnos, puedes adjuntar un recurso Link, DriveFile o YouTubeVideo. Para ello, usa courses.courseWork.studentSubmissions.modifyAttachments, como se muestra en el siguiente ejemplo:

Java

classroom/fragmentos/src/main/java/ModifyAttachmentsStudentSubmission.java

Ver en GitHub

StudentSubmission studentSubmission = null;
try {
  // Create ModifyAttachmentRequest object that includes a new attachment with a link.
  Link link = new Link().setUrl("https://en.wikipedia.org/wiki/Irrational_number");
  Attachment attachment = new Attachment().setLink(link);
  ModifyAttachmentsRequest modifyAttachmentsRequest =
      new ModifyAttachmentsRequest().setAddAttachments(Arrays.asList(attachment));

  // The modified studentSubmission object is returned with the new attachment added to it.
  studentSubmission =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .modifyAttachments(courseId, courseWorkId, id, modifyAttachmentsRequest)
          .execute();

  /* Prints the modified student submission. */
  System.out.printf(
      "Modified student submission attachments: '%s'.\n",
      studentSubmission.getAssignmentSubmission().getAttachments());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmission;

Python

classroom/fragmentos/classroom_add_attachment.py

Ver en GitHub


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 archivo adjunto de vínculo; Classroom recuperará automáticamente el título y la imagen de la miniatura. Puedes obtener información sobre los demás materiales en sus respectivas páginas de referencia.

Solo un profesor del curso o el alumno propietario puede modificar StudentSubmission. Solo puedes adjuntar Materials si el CourseWorkType de la entrega del alumno es ASSIGNMENT.

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

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

Usa el siguiente permiso 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 en 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:

Java

classroom/fragmentos/src/main/java/ReturnStudentSubmission.java

Ver en GitHub

try {
  service
      .courses()
      .courseWork()
      .studentSubmissions()
      .classroomReturn(courseId, courseWorkId, id, null)
      .execute();
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}

Python

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

Solo el alumno que posee un StudentSubmission puede entregarlo o reclamarlo. Solo se puede reclamar un envío entregado. Los profesores del curso solo pueden mostrar un StudentSubmission que tenga el estado.

Esto no cambia el valor de assignedGrade or draftGrade. Para ver la calificación al alumno, consulta la sección Cómo calificar el trabajo de los alumnos.

Califica las respuestas de los alumnos

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

Java

classroom/fragmentos/src/main/java/PatchStudentSubmission.java

Ver en GitHub

StudentSubmission studentSubmission = null;
try {
  // Updating the draftGrade and assignedGrade fields for the specific student submission.
  StudentSubmission content =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .get(courseId, courseWorkId, id)
          .execute();
  content.setAssignedGrade(90.00);
  content.setDraftGrade(80.00);

  // The updated studentSubmission object is returned with the new draftGrade and assignedGrade.
  studentSubmission =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .patch(courseId, courseWorkId, id, content)
          .set("updateMask", "draftGrade,assignedGrade")
          .execute();

  /* Prints the updated student submission. */
  System.out.printf(
      "Updated student submission draft grade (%s) and assigned grade (%s).\n",
      studentSubmission.getDraftGrade(), studentSubmission.getAssignedGrade());
} catch (GoogleJsonResponseException e) {
  // TODO (developer) - handle error appropriately
  GoogleJsonError error = e.getDetails();
  if (error.getCode() == 404) {
    System.out.printf(
        "The courseId (%s), courseWorkId (%s), or studentSubmissionId (%s) does "
            + "not exist.\n",
        courseId, courseWorkId, id);
  } else {
    throw e;
  }
} catch (Exception e) {
  throw e;
}
return studentSubmission;

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 hayan guardado la calificación preliminar. Luego, la calificación asignada se puede devolver a un alumno. Las aplicaciones deben emular este comportamiento. Tu aplicación puede calificar la tarea de un alumno de dos maneras:

Asigna solo 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 el draftGrade y la assignedGrade para calificar por completo una tarea.

No configures el assignedGrade sin configurar también el draftGrade. Configurar solo “assignedGrade” puede provocar un comportamiento extraño en la IU de Classroom.

Enumerar las calificaciones asignadas

Puedes enumerar todas las calificaciones de un elemento del curso en particular explorando el objeto de respuesta del método courses.courseWork.studentSubmissions.list:

Java

classroom/fragmentos/src/main/java/ListStudentSubmissions.java

Ver en GitHub

  ListStudentSubmissionsResponse response =
      service
          .courses()
          .courseWork()
          .studentSubmissions()
          .list(courseId, courseWorkId)
          .setPageToken(pageToken)
          .execute();

  /* Ensure that the response is not null before retrieving data from it to avoid errors. */
  if (response.getStudentSubmissions() != null) {
    studentSubmissions.addAll(response.getStudentSubmissions());
    pageToken = response.getNextPageToken();
  }
} while (pageToken != null);

if (studentSubmissions.isEmpty()) {
  System.out.println("No student submissions found.");
} else {
  for (StudentSubmission submission : studentSubmissions) {
    System.out.printf(
        "User ID %s, Assigned grade: %s\n",
        submission.getUserId(), submission.getAssignedGrade());
  }
}

Python

response = coursework.studentSubmissions().list(
    courseId=course_id,
    courseWorkId=coursework_id,
    pageSize=10).execute()
submissions.extend(response.get('studentSubmissions', []))

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

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