Adição de Alunos ao Google Classroom com Python
Published: 2024-05-20 14:35:56

Olá pessoal tudo bem?,
Conteúdo com objetivo de explicar passo a passo o funcionamento de um script Python que autentica um usuário, lista cursos no Google Classroom e permite a adição de alunos aos cursos. Este script utiliza várias bibliotecas da API do Google para autenticação e acesso ao Google Classroom.

E com isto nos é exibido também o ID da sala criada.

- Bibliotecas Utilizadas :

- os.path: Para verificar a existência de arquivos.

- google.auth.transport.requests.Request: Para fazer solicitações de autenticação.

- google.oauth2.credentials.Credentials: Para gerenciar credenciais OAuth 2.0.

- google_auth_oauthlib.flow.InstalledAppFlow: Para gerenciar o fluxo de OAuth 2.0.

- googleapiclient.discovery.build: Para construir o serviço de API do Google.

- googleapiclient.errors.HttpError: Para tratar erros da API do Google.

```
Escopos necessários para pesquisa de módulos de ensalamento :

SCOPES = [
    "https://www.googleapis.com/auth/classroom.courses.readonly",
    "https://www.googleapis.com/auth/classroom.rosters"
]

```
**Função Principal**
**Definição e Objetivo**
A função main() é responsável por gerenciar todo o fluxo de autenticação e execução das ações principais do script:

```
def main():
    """
    Código usado para poder criar e exibir as salas do Google criadas e adicionar alunos aos cursos e exibir também o ID do curso criado.
    """

```
**Autenticação**
Verificação de Credenciais Existentes:

- Verifica se o arquivo token.json (contendo credenciais salvas) existe.

- Se existir, carrega as credenciais a partir desse arquivo.

```
creds = None
if os.path.exists("token.json"):
    creds = Credentials.from_authorized_user_file("token.json", SCOPES)


```

**A token JSON é gerada na hora de autorizar o aplicativo para tal, existe uma, as tokens são diferentes das chaves criadas no ambiente **

**Autenticação e Renovação de Credenciais:

**

- Se as credenciais não existem ou são inválidas, o script solicita autenticação.

- Utiliza o fluxo de autenticação OAuth 2.0 para obter novas credenciais e salva em token.json.

```
if not creds or not creds.valid:
    if creds and creds.expired and creds.refresh_token:
        creds.refresh(Request())
    else:
        flow = InstalledAppFlow.from_client_secrets_file(
            "credentials.json", SCOPES
        )
        creds = flow.run_local_server(port=0)
    with open("token.json", "w") as token:
        token.write(creds.to_json())

```

**Construção do Serviço e Listagem de Cursos
**

**Construção do Serviço:

**

- Usa as credenciais para construir o serviço da API do Google Classroom.

```
service = build("classroom", "v1", credentials=creds)

```

**Listagem de Cursos:**

- Chama a API para listar até 1000 cursos. (lembrando que este valor de 1000, foi utilizado de exemplos, mas você pode definir qual valor quiser).

- Verifica se há cursos e imprime os nomes e IDs dos cursos encontrados.

```
results = service.courses().list(pageSize=1000).execute()
courses = results.get("courses", [])

if not courses:
    print("No courses found.")
    return
print("Courses:")
for course in courses:
    print(f'{course["name"]} (ID: {course["id"]})')

```

**Adição de Aluno ao Curso**

**Solicitação de Dados do Usuário:**

- Solicita ao usuário o ID do curso e o e-mail do aluno a ser adicionado.

```
course_id = input("Digite o ID do curso para adicionar um aluno: ")
student_email = input("Digite o e-mail do aluno: ")

```

**Chamada da Função de Adição:**

- Chama a função add_student_to_course passando o serviço, o ID do curso e o e-mail do aluno.

```
add_student_to_course(service, course_id, student_email)


```
**Tratamento de Erros**

- Qualquer erro na execução da API é capturado e impresso no console.

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

```
**Função para Adicionar Aluno**

> Definição e Execução

> A função add_student_to_course adiciona um aluno a um curso específico:

```
def add_student_to_course(service, course_id, student_email):
    try:
        student = {
            'userId': student_email
        }
        student = service.courses().students().create(courseId=course_id, body=student).execute()
        print(f"Student {student_email} added to course {course_id}")
    except HttpError as error:
        print(f"An error occurred: {error}")

```

**Passos**

- Criação do Corpo da Requisição:

- Define o corpo da requisição com o e-mail do aluno.

```
student = {
    'userId': student_email
}

```
**Chamada da API para Adicionar o Aluno:**

- Usa a API do Classroom para adicionar o aluno ao curso.

```
student = service.courses().students().create(courseId=course_id, body=student).execute()

```
**Execução do Script**

- Ao executar o script, ele primeiro remove qualquer arquivo token.json existente para forçar a reautenticação, garantindo que as credenciais estão atualizadas:

```
if __name__ == "__main__":
    if os.path.exists("token.json"):
        os.remove("token.json")
    main()

```



**CÓDIGO COMPLETO**

```
import os.path
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# Escopos necessários para listar cursos e adicionar alunos no Google Classroom
SCOPES = [
    "https://www.googleapis.com/auth/classroom.courses.readonly",
    "https://www.googleapis.com/auth/classroom.rosters"
]

def main():
    """
    Código usado para poder criar e exibir as salas do Google criadas e adicionar alunos aos cursos.
    """
    creds = None
    if os.path.exists("token.json"):
        creds = Credentials.from_authorized_user_file("token.json", SCOPES)
    # Vai pedir autenticação 
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                "credentials.json", SCOPES
            )
            creds = flow.run_local_server(port=0)
        # Salva as credenciais e mostra os cursos
        with open("token.json", "w") as token:
            token.write(creds.to_json())

    try:
        service = build("classroom", "v1", credentials=creds)

        # Chama a API Do classroom para ver os cursos deixar em 1000
        results = service.courses().list(pageSize=1000).execute()
        courses = results.get("courses", [])

        if not courses:
            print("No courses found.")
            return
        # Mostra na tela o nome dos cursos criados e salas
        print("Courses:")
        for course in courses:
            print(f'{course["name"]} (ID: {course["id"]})')

        # Adicionar aluno ao curso
        course_id = input("Digite o ID do curso para adicionar um aluno: ")
        student_email = input("Digite o e-mail do aluno: ")
        add_student_to_course(service, course_id, student_email)

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

def add_student_to_course(service, course_id, student_email):
    try:
        student = {
            'userId': student_email
        }
        student = service.courses().students().create(courseId=course_id, body=student).execute()
        print(f"Student {student_email} added to course {course_id}")
    except HttpError as error:
        print(f"An error occurred: {error}")

if __name__ == "__main__":
    # Apagar o arquivo token.json para forçar a reautenticação
    if os.path.exists("token.json"):
        os.remove("token.json")
    main()

```
**Exibição de Imagem com ID dos Cursos**
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/w7ntdf05de2jw6qh484g.png)