Criar eventos

Imagine um app que ajude os usuários a encontrar as melhores rotas para caminhadas. Quando o plano de caminhada é adicionado como um evento da agenda, os usuários conseguem se organizar de forma automática. O Google Agenda ajuda a compartilhar o plano e os lembra sobre ele, para que possam se preparar sem estresse. Além disso, graças à integração perfeita dos produtos do Google, o Google Now avisa sobre o horário de saída e o Google Maps os direciona para o ponto de encontro a tempo.

Este artigo explica como criar eventos da agenda e adicioná-los às agendas dos usuários.

Adicionar um evento

Para criar um evento, chame o método events.insert() fornecendo pelo menos estes parâmetros:

• calendarId é o identificador da agenda e pode ser o endereço de e-mail da agenda em que o evento será criado ou uma palavra-chave especial 'primary', que usará a agenda principal do usuário conectado. Caso você não saiba o endereço de e-mail da agenda que quer usar, confira as configurações na interface da Web do Google Agenda (na seção "Endereço da agenda") ou procure por ele no resultado da chamada calendarList.list().
• event é o evento a ser criado com todos os detalhes necessários, como início e fim. Os dois únicos campos obrigatórios são start e end. Consulte a referência do event para o conjunto completo de campos do evento.
  Especifique eventos com tempo determinado usando os campos start.dateTime e end.dateTime. Para eventos de dia inteiro, use start.date e end.date.

Para criar eventos, você precisa:

• Defina o escopo do OAuth como https://www.googleapis.com/auth/calendar para ter acesso para editar a agenda do usuário.
• Verifique se o usuário autenticado tem acesso de gravação à agenda com o calendarId fornecido. Por exemplo, chame calendarList.get() para calendarId e verifique accessRole.

Adicionar metadados do evento

Também é possível adicionar metadados de eventos ao criar um evento da agenda. Se você optar por não adicionar metadados durante a criação, poderá atualizar muitos campos usando events.update(). No entanto, alguns campos, como o ID do evento, só podem ser definidos durante uma operação events.insert().

Local

Adicionar um endereço no campo de local ativa recursos como

"hora de sair" ou exibir um mapa com as rotas.

Código do evento

Ao criar um evento, você pode gerar seu próprio ID de evento

está de acordo com nossos requisitos de formato. Isso permite manter as entidades no banco de dados local sincronizadas com os eventos no Google Agenda. Ele também impede a criação de eventos duplicados se a operação falhar em algum momento depois de ser executada no back-end do Google Agenda. Se nenhum ID de evento for fornecido, o servidor vai gerar um para você. Consulte a referência do ID do evento para mais informações.

Participantes

O evento criado aparece em todas as agendas principais do Google

os convidados que você incluiu com o mesmo ID do evento. Se você definir sendNotifications como true na sua solicitação de inserção, os participantes também receberão uma notificação por e-mail sobre o evento. Consulte o guia eventos com vários participantes para mais informações.

Os exemplos a seguir mostram a criação de um evento e a definição dos metadados dele:

Go

// Refer to the Go quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/go
// Change the scope to calendar.CalendarScope and delete any stored credentials.

event := &calendar.Event{
  Summary: "Google I/O 2015",
  Location: "800 Howard St., San Francisco, CA 94103",
  Description: "A chance to hear more about Google's developer products.",
  Start: &calendar.EventDateTime{
    DateTime: "2015-05-28T09:00:00-07:00",
    TimeZone: "America/Los_Angeles",
  },
  End: &calendar.EventDateTime{
    DateTime: "2015-05-28T17:00:00-07:00",
    TimeZone: "America/Los_Angeles",
  },
  Recurrence: []string{"RRULE:FREQ=DAILY;COUNT=2"},
  Attendees: []*calendar.EventAttendee{
    &calendar.EventAttendee{Email:"[e-mail]"},
    &calendar.EventAttendee{Email:"[e-mail]"},
  },
}

calendarId := "primary"
event, err = srv.Events.Insert(calendarId, event).Do()
if err != nil {
  log.Fatalf("Unable to create event. %v\n", err)
}
fmt.Printf("Event created: %s\n", event.HtmlLink)

Java

// Refer to the Java quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/java
// Change the scope to CalendarScopes.CALENDAR and delete any stored
// credentials.

Event event = new Event()
    .setSummary("Google I/O 2015")
    .setLocation("800 Howard St., San Francisco, CA 94103")
    .setDescription("A chance to hear more about Google's developer products.");

DateTime startDateTime = new DateTime("2015-05-28T09:00:00-07:00");
EventDateTime start = new EventDateTime()
    .setDateTime(startDateTime)
    .setTimeZone("America/Los_Angeles");
event.setStart(start);

DateTime endDateTime = new DateTime("2015-05-28T17:00:00-07:00");
EventDateTime end = new EventDateTime()
    .setDateTime(endDateTime)
    .setTimeZone("America/Los_Angeles");
event.setEnd(end);

String[] recurrence = new String[] {"RRULE:FREQ=DAILY;COUNT=2"};
event.setRecurrence(Arrays.asList(recurrence));

EventAttendee[] attendees = new EventAttendee[] {
    new EventAttendee().setEmail("[e-mail]"),
    new EventAttendee().setEmail("[e-mail]"),
};
event.setAttendees(Arrays.asList(attendees));

EventReminder[] reminderOverrides = new EventReminder[] {
    new EventReminder().setMethod("email").setMinutes(24 * 60),
    new EventReminder().setMethod("popup").setMinutes(10),
};
Event.Reminders reminders = new Event.Reminders()
    .setUseDefault(false)
    .setOverrides(Arrays.asList(reminderOverrides));
event.setReminders(reminders);

String calendarId = "primary";
event = service.events().insert(calendarId, event).execute();
System.out.printf("Event created: %s\n", event.getHtmlLink());

JavaScript

// Refer to the JavaScript quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/js
// Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
// stored credentials.

const event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles'
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles'
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'}
  ],
  'reminders': {
    'useDefault': false,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10}
    ]
  }
};

const request = gapi.client.calendar.events.insert({
  'calendarId': 'primary',
  'resource': event
});

request.execute(function(event) {
  appendPre('Event created: ' + event.htmlLink);
});

Node.js

// Refer to the Node.js quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/node
// Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
// stored credentials.

const event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'},
  ],
  'reminders': {
    'useDefault': false,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10},
    ],
  },
};

calendar.events.insert({
  auth: auth,
  calendarId: 'primary',
  resource: event,
}, function(err, event) {
  if (err) {
    console.log('There was an error contacting the Calendar service: ' + err);
    return;
  }
  console.log('Event created: %s', event.htmlLink);
});

PHP

$event = new Google_Service_Calendar_Event(array(
  'summary' => 'Google I/O 2015',
  'location' => '800 Howard St., San Francisco, CA 94103',
  'description' => 'A chance to hear more about Google\'s developer products.',
  'start' => array(
    'dateTime' => '2015-05-28T09:00:00-07:00',
    'timeZone' => 'America/Los_Angeles',
  ),
  'end' => array(
    'dateTime' => '2015-05-28T17:00:00-07:00',
    'timeZone' => 'America/Los_Angeles',
  ),
  'recurrence' => array(
    'RRULE:FREQ=DAILY;COUNT=2'
  ),
  'attendees' => array(
    array('email' => '[e-mail]'),
    array('email' => '[e-mail]'),
  ),
  'reminders' => array(
    'useDefault' => FALSE,
    'overrides' => array(
      array('method' => 'email', 'minutes' => 24 * 60),
      array('method' => 'popup', 'minutes' => 10),
    ),
  ),
));

$calendarId = 'primary';
$event = $service->events->insert($calendarId, $event);
printf('Event created: %s\n', $event->htmlLink);

Python

# Refer to the Python quickstart on how to setup the environment:
# https://developers.google.com/calendar/quickstart/python
# Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
# stored credentials.

event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'},
  ],
  'reminders': {
    'useDefault': False,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10},
    ],
  },
}

event = service.events().insert(calendarId='primary', body=event).execute()
print 'Event created: %s' % (event.get('htmlLink'))

Ruby

event = Google::Apis::CalendarV3::Event.new(
  summary: 'Google I/O 2015',
  location: '800 Howard St., San Francisco, CA 94103',
  description: 'A chance to hear more about Google\'s developer products.',
  start: Google::Apis::CalendarV3::EventDateTime.new(
    date_time: '2015-05-28T09:00:00-07:00',
    time_zone: 'America/Los_Angeles'
  ),
  end: Google::Apis::CalendarV3::EventDateTime.new(
    date_time: '2015-05-28T17:00:00-07:00',
    time_zone: 'America/Los_Angeles'
  ),
  recurrence: [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  attendees: [
    Google::Apis::CalendarV3::EventAttendee.new(
      email: '[e-mail]'
    ),
    Google::Apis::CalendarV3::EventAttendee.new(
      email: '[e-mail]'
    )
  ],
  reminders: Google::Apis::CalendarV3::Event::Reminders.new(
    use_default: false,
    overrides: [
      Google::Apis::CalendarV3::EventReminder.new(
        reminder_method: 'email',
        minutes: 24 * 60
      ),
      Google::Apis::CalendarV3::EventReminder.new(
        reminder_method: 'popup',
        minutes: 10
      )
    ]
  )
)

result = client.insert_event('primary', event)
puts "Event created: #{result.html_link}"

Adicionar anexos do Drive a eventos

Você pode anexar arquivos do Google Drive, como atas de reunião no Documentos, orçamentos no Planilhas, apresentações no Apresentações ou qualquer outro arquivo relevante do Google Drive aos seus eventos da agenda. É possível adicionar o anexo ao criar um evento com events.insert() ou depois como parte de uma atualização, como events.patch().

As duas etapas para anexar um arquivo do Google Drive a um evento são:

1. Consiga o URL alternateLink, title e mimeType do arquivo no recurso de arquivos da API Drive, geralmente com o método files.get().
2. Crie ou atualize um evento com os campos attachments definidos no corpo da solicitação e o parâmetro supportsAttachments definido como true.

O exemplo de código a seguir demonstra como atualizar um evento existente para adicionar um anexo:

Java

public static void addAttachment(Calendar calendarService, Drive driveService, String calendarId,
    String eventId, String fileId) throws IOException {
  File file = driveService.files().get(fileId).execute();
  Event event = calendarService.events().get(calendarId, eventId).execute();

  List<EventAttachment> attachments = event.getAttachments();
  if (attachments == null) {
    attachments = new ArrayList<EventAttachment>();
  }
  attachments.add(new EventAttachment()
      .setFileUrl(file.getAlternateLink())
      .setMimeType(file.getMimeType())
      .setTitle(file.getTitle()));

  Event changes = new Event()
      .setAttachments(attachments);
  calendarService.events().patch(calendarId, eventId, changes)
      .setSupportsAttachments(true)
      .execute();
}

PHP

function addAttachment($calendarService, $driveService, $calendarId, $eventId, $fileId) {
  $file = $driveService->files->get($fileId);
  $event = $calendarService->events->get($calendarId, $eventId);
  $attachments = $event->attachments;

  $attachments[] = array(
    'fileUrl' => $file->alternateLink,
    'mimeType' => $file->mimeType,
    'title' => $file->title
  );
  $changes = new Google_Service_Calendar_Event(array(
    'attachments' => $attachments
  ));

  $calendarService->events->patch($calendarId, $eventId, $changes, array(
    'supportsAttachments' => TRUE
  ));
}

Python

def add_attachment(calendarService, driveService, calendarId, eventId, fileId):
    file = driveService.files().get(fileId=fileId).execute()
    event = calendarService.events().get(calendarId=calendarId,
                                         eventId=eventId).execute()

    attachments = event.get('attachments', [])
    attachments.append({
        'fileUrl': file['alternateLink'],
        'mimeType': file['mimeType'],
        'title': file['title']
    })

    changes = {
        'attachments': attachments
    }
    calendarService.events().patch(calendarId=calendarId, eventId=eventId,
                                   body=changes,
                                   supportsAttachments=True).execute()

Importante: é necessário fazer uma sincronização completa de todos os eventos antes de ativar o parâmetro supportsAttachments para modificações de eventos ao adicionar compatibilidade com anexos no app que armazena eventos localmente. Se você não fizer uma sincronização primeiro, poderá remover acidentalmente os anexos dos eventos do usuário.

Adicionar videoconferências e ligações a eventos

Você pode associar eventos a videoconferências do Hangouts e do Google Meet para permitir que os usuários se reúnam remotamente por telefone ou videochamada.

O campo conferenceData pode ser usado para ler, copiar e limpar detalhes da videoconferência. Ele também pode ser usado para solicitar a geração de novas conferências. Para permitir a criação e a modificação de detalhes da videoconferência, defina o parâmetro de solicitação conferenceDataVersion como 1.

Atualmente, existem três tipos de conferenceData com suporte, conforme indicado pelo conferenceData.conferenceSolution.key.type:

1. Hangouts para consumidores (eventHangout)
2. Hangouts clássico para Google Workspace usuários (descontinuado; eventNamedHangout)
3. Google Meet (hangoutsMeet)

Para saber qual tipo de videoconferência é compatível com qualquer agenda de um usuário, consulte o conferenceProperties.allowedConferenceSolutionTypes nas coleções calendars e calendarList. Para saber se o usuário prefere que o Hangouts seja criado para todos os eventos recém-criados, verifique a configuração autoAddHangouts na coleção settings.

Além de type, conferenceSolution também fornece os campos name e iconUri, que podem ser usados para representar a solução de conferência, conforme mostrado abaixo:

JavaScript

const solution = event.conferenceData.conferenceSolution;

const content = document.getElementById("content");
const text = document.createTextNode("Join " + solution.name);
const icon = document.createElement("img");
icon.src = solution.iconUri;

content.appendChild(icon);
content.appendChild(text);

É possível criar uma nova conferência para um evento fornecendo um createRequest com um requestId recém-gerado, que pode ser um string aleatório. As conferências são criadas de forma assíncrona, mas você sempre pode verificar o status da sua solicitação para informar aos usuários o que está acontecendo.

Por exemplo, para solicitar a geração de videoconferências para um evento existente:

JavaScript

const eventPatch = {
  conferenceData: {
    createRequest: {requestId: "7qxalsvy0e"}
  }
};

gapi.client.calendar.events.patch({
  calendarId: "primary",
  eventId: "7cbh8rpc10lrc0ckih9tafss99",
  resource: eventPatch,
  sendNotifications: true,
  conferenceDataVersion: 1
}).execute(function(event) {
  console.log("Conference created for event: %s", event.htmlLink);
});

A resposta imediata a essa chamada pode ainda não conter o conferenceData totalmente preenchido. Isso é indicado por um código de status de pending no campo status. O código de status muda para success depois que as informações da videoconferência são preenchidas. O campo entryPoints contém informações sobre quais URIs de vídeo e telefone estão disponíveis para os usuários ligarem.

Para programar vários eventos do Agenda com os mesmos detalhes de conferência, copie todo o conferenceData de um evento para outro.

Copiar é útil em determinadas situações. Por exemplo, suponha que você esteja desenvolvendo um aplicativo de recrutamento que configura eventos separados para o candidato e o entrevistador. Você quer proteger a identidade do entrevistador, mas também quer garantir que todos os participantes participem da mesma conferência.

Importante: é necessário fazer uma sincronização completa de todos os eventos antes de ativar o suporte a dados de videoconferência (configurando o parâmetro de solicitação conferenceDataVersion como 1 para modificações de eventos) ao adicionar suporte de videoconferência ao seu app que armazena eventos localmente. Se você não fizer uma sincronização primeiro, poderá remover inadvertidamente as conferências atuais dos eventos dos usuários.