O Google Forms é a solução mais popular no mercado para a coleta de dados, respostas a questionários e quizzes. Por isso, é a ferramenta ideal para coletar dados e respostas de pacientes de forma prática, eliminando a necessidade de expandir ou desenvolver sistemas complexos.
Neste artigo, vou detalhar como criar uma conta no Google Cloud, registrar a aplicação que irá consumir a API do Google Forms, gerar o usuário de serviço necessário para consumir a API e, por fim, realizar ações para criar novos formulários e coletar os dados preenchidos neles de forma automatizada em Python e IRIS embutido.
Crie Sua Conta Google Cloud
Se você ainda não tem uma conta Google Cloud, siga estes passos. Caso contrário, vá para a próxima seção.
Para criar uma conta no Google Cloud Platform (GCP), você primeiro precisa de uma conta Google. Depois, você pode fazer login no console do Google Cloud e começar a usar o nível gratuito ou criar uma conta paga. Veja um guia passo a passo:
1. Acesse o console do Google Cloud: Visite cloud.google.com.
2. Faça login com sua conta Google: Se você não tiver uma, precisará criar uma.
3. Aceite os termos e condições: Revise e aceite os termos e condições do Google Cloud.
4. Comece Gratuitamente ou Crie uma Conta de Faturamento:
a. Nível Gratuito: Você pode começar a usar o Google Cloud gratuitamente com o nível gratuito
b. Conta Paga: Se precisar de mais recursos ou funcionalidades avançadas, você precisará criar uma conta de faturamento.
5. Crie uma Conta de Faturamento (se necessário): Se você optar por criar uma conta paga, precisará configurar uma conta de faturamento, o que exige o fornecimento de detalhes de verificação de pagamento e informações sobre sua organização.
6. Comece a Usar: Assim que sua conta estiver configurada, você poderá acessar o console do Google Cloud e começar a usar os serviços.
Criar um Projeto Google Cloud
É obrigatório criar um projeto para usar as APIs e SDKs do Google em seus programas.
Acesse este link e siga os passos:
https://developers.google.com/workspace/guides/create-project
Criar uma Conta de Serviço Google Cloud
É necessário criar uma conta de serviço (credenciais para aplicações) para que sua aplicação possa consumir a API do Google Forms.
1. Acesse https://console.cloud.google.com/projectselector2/iam-admin/serviceaccounts , e selecione o projeto que você criou na seção anterior.
2. Clique no botão + Criar conta de serviço, preencha os campos obrigatórios e clique em Criar e continuar.
3. Selecione a função Proprietário e clique no botão Continuar.
4 . Salve seu arquivo JSON de credenciais para usar posteriormente.
5. Clique no botão Concluir (Done).
6. Clique no botão de 3 pontos e selecione Gerenciar chaves.
.png)
7. Clique no botão Adicionar chave > Criar nova chave.
8. Selecione JSON e clique em Criar.
.png)
9. As credenciais são salvas na sua página de downloads. SALVE ESTE ARQUIVO PORQUE IREI USÁ-LO MAIS TARDE.
Ativar as APIs do Google Forms e do Google Drive
Para que seu projeto possa consumir as APIs do Google Forms e do Google Drive (porque o Drive armazena as definições dos formulários do Google), você deve ativar o acesso:
1. Vá para https://console.cloud.google.com/apis/dashboard
2. Clique no botão "+ Ativar APIs e serviços".
3. Pesquise por "Google Drive API" no campo superior "Pesquisar APIs e serviços", selecione "Google Drive API" e ative a API, se ainda não estiver ativada.
4. Repita o passo 3 e pesquise por Google Forms API no campo superior "Pesquisar APIs e serviços", selecione Google Forms API e ative a API, se ainda não estiver ativada.
Obtenha e Execute o Projeto health-gforms
Criei uma aplicação de exemplo (health-gforms em https://openexchange.intersystems.com/package/health-gforms) que cria um Google Form e coleta dados dele.
1. Clone/faça um git pull do repositório em qualquer diretório local.
$ git clone https://github.com/yurimarx/health-gforms/health-gforms.git
2. Abra o terminal neste diretório e execute:
$ docker-compose build
$ docker-compose up -d
Usando a API health-gforms via Postman
1. Baixe (https://www.postman.com/downloads/) e instale o aplicativo Postman, se você ainda não o tiver.
2. Baixe a coleção Postman em https://github.com/yurimarx/health-gforms/raw/refs/heads/master/health-g...
3. Importe esta coleção para o seu Postman:
.png)
4. Clique em "1. Post credentials" para carregar as credenciais da conta de serviço do Google Cloud para sua instância Docker:
.png)
5. Abra "2. Post form definition" para salvar a definição do formulário (use um arquivo da pasta raiz do projeto, formpatient.json) em sua instância Docker
.png)
6. Clique em "3. Create form from file definition" para criar um novo formulário Google no Google Cloud e coletar dados sobre um novo paciente: .png)
7. Copie o valor para formId: .png)
8. Abra os Formulários Google usando seu navegador (preste atenção ao valor de formId, eu o usei no caminho: https://docs.google.com/forms/d/1DtqV5edXVOjM-FAntPffRHqfVjMjOIJuiq5VXBc...
.png)
9. Para preencher os Formulários Google como usuário final, vá até o botão "participant link" e cole em uma nova aba do navegador: .png)
10. Preencha o formulário como usuário final:
.png)
11. Cole as respostas do formulário.
12. Clique em "4. Get form content from template" e mude o valor de formId para o formId fornecido na etapa 7: .png)
13. Clique no botão enviar e veja o conteúdo JSON FHIR para enviar ao seu servidor FHIR:
.png)
Nos Bastidores
Criando um Formulário nos Formulários Google:
ClassMethod CreateFormFromFile(formtitle As %String, filepath As %String) [ Language = python ]
{
import httplib2
import json
from oauth2client.service_account import ServiceAccountCredentials
from googleapiclient.discovery import build
from mako.template import Template
credentials = ServiceAccountCredentials.from_json_keyfile_name(
"/opt/irisapp/credentials.json",
scopes=["https://www.googleapis.com/auth/forms.body",
"https://www.googleapis.com/auth/forms",
"https://www.googleapis.com/auth/drive",
"https://www.googleapis.com/auth/drive.file"],
)
http = httplib2.Http()
http = credentials.authorize(http)
form_service = build("forms", "v1", http=http)
new_form_template = Template('{"info": {"title": "${title}"}}')
new_form_str = new_form_template.render(title=formtitle)
NEW_FORM = json.loads(new_form_str)
# Create the form
try:
result = form_service.forms().create(body=NEW_FORM).execute()
formid = result["formId"]
print(f'Form created: {result}')
with open(filepath) as file:
itemsjson = json.loads(file.read())
# Adds form items
items = (
form_service.forms()
.batchUpdate(formId=formid, body=itemsjson)
.execute()
)
permission2 = {
'type': 'anyone',
'role': 'writer',
}
drive_service = build('drive', 'v3', credentials=credentials)
drive_service.permissions().create(fileId=formid, body=permission2).execute()
return formid
except Exception as e:
print(f'Error creating form: {e}')
}
1. Nós criamos as credenciais usando os dados da conta de serviço dentro de um arquivo JSON de credenciais para as APIs de formulários e drive.
2. Nós usamos essas credenciais para construir um form_service.
3. O form_service é usado para criar o Formulário Google apenas com o cabeçalho.
4. O form_service lê o arquivo formpatient.json para criar os itens do formulário (campos ou perguntas). Veja o conteúdo deste arquivo:
{
"requests": [
{
"createItem": {
"item": {
"title": "Given Name",
"questionItem": {
"question": {
"required": true,
"textQuestion": {}
}
}
},
"location": {"index": 0}
}
},
{
"createItem": {
"item": {
"title": "Family Name",
"questionItem": {
"question": {
"required": true,
"textQuestion": {}
}
}
},
"location": {"index": 1}
}
},
{
"createItem": {
"item": {
"title": "Gender",
"questionItem": {
"question": {
"required": true,
"choiceQuestion": {
"type": "RADIO",
"options": [
{
"value": "male"
},
{
"value": "female"
}
]
}
}
}
},
"location": {"index": 2}
}
},
{
"createItem": {
"item": {
"title": "Birth Date",
"questionItem": {
"question": {
"required": true,
"dateQuestion": {
"includeYear": true
}
}
}
},
"location": {"index": 3}
}
},
{
"createItem": {
"item": {
"title": "Phone",
"questionItem": {
"question": {
"required": true,
"textQuestion": {}
}
}
},
"location": {"index": 4}
}
}
]
}
5. Agora temos um novo formulário.
Colete respostas de dados do usuário de um Formulário Google:
ClassMethod GetResponsesFromFormId(formid As %String) [ Language = python ]
{
import httplib2
from oauth2client.service_account import ServiceAccountCredentials
from googleapiclient.discovery import build
credentials = ServiceAccountCredentials.from_json_keyfile_name(
"/opt/irisapp/credentials.json",
scopes="https://www.googleapis.com/auth/forms.responses.readonly",
)
# Create an httplib2.Http object to handle our HTTP requests and authorize
# it with the Credentials.
http = httplib2.Http()
http = credentials.authorize(http)
form_service = build("forms", "v1", http=http)
# Prints the responses of your specified form:
result = form_service.forms().responses().list(formId=formid).execute()
return result
}
1. Um objeto de credencial é criado usando a conta de serviço definida em credentials.json com autorização para ler os Formulários Google.
2. Um form_service é criado a partir das credenciais.
3. O form_service é usado para obter todas as respostas de um formId.
Open Exchange