Criar eventos

Imagine um app que ajude os usuários a encontrar as melhores rotas de caminhada. Ao adicionar o plano de caminhada como um evento da agenda, os usuários recebem muita ajuda para se manterem organizados automaticamente. O Google Agenda ajuda a compartilhar o plano e lembra as pessoas sobre ele para que elas 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 sair, e o Google Maps direciona as pessoas ao local da reunião a tempo.

Neste artigo, explicamos como criar eventos 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 usa a agenda principal do usuário conectado. Se você não souber o endereço de e-mail da agenda que quer usar, verifique nas configurações da interface da Web do Google Agenda (na seção "Endereço da agenda") ou procure no resultado da chamada calendarList.list().
  • event é o evento a ser criado com todos os detalhes necessários, como início e fim. Os únicos campos obrigatórios são os horários start e end. Consulte a referência de event para ver o conjunto completo de campos de evento.

Para criar eventos, você precisa:

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

Adicionar metadados de evento

Você pode adicionar metadados de eventos ao criar um evento na agenda. Se você não adicionar metadados durante a criação, poderá atualizar muitos campos usando o 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 mostra um mapa com as rotas.
ID do evento
Ao criar um evento, você pode gerar seu próprio ID que esteja de acordo com nossos requisitos de formato. Isso permite que você mantenha as entidades no seu banco de dados local sincronizadas com os eventos no Google Agenda. Ele também evita a criação de eventos duplicados se a operação falhar em algum momento após ser executada com êxito no back-end do Google Agenda. Se nenhum ID de evento for fornecido, o servidor vai gerar um para você. Consulte a referência de ID do evento para mais informações.
Participantes
O evento criado aparece em todas as agendas principais do Google dos participantes incluídos com o mesmo ID de evento. Se você definir sendUpdates como "all" ou "externalOnly" na sua solicitação de inserção, os participantes correspondentes vão receber uma notificação por e-mail sobre o evento. Para saber mais, consulte eventos com vários participantes.

Os exemplos a seguir mostram como criar um evento e definir os metadados dele:

Go

// Refer to the Go quickstart on how to setup the environment:
// https://developers.google.com/workspace/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:"[email protected]"},
    &calendar.EventAttendee{Email:"[email protected]"},
  },
}

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/workspace/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("[email protected]"),
    new EventAttendee().setEmail("[email protected]"),
};
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/workspace/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': '[email protected]'},
    {'email': '[email protected]'}
  ],
  '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/workspace/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': '[email protected]'},
    {'email': '[email protected]'},
  ],
  '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' => '[email protected]'),
    array('email' => '[email protected]'),
  ),
  '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/workspace/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': '[email protected]'},
    {'email': '[email protected]'},
  ],
  '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: '[email protected]'
    ),
    Google::Apis::CalendarV3::EventAttendee.new(
      email: '[email protected]'
    )
  ],
  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ões nos Documentos, orçamentos nas Planilhas, apresentações no Apresentações ou qualquer outro arquivo relevante do Google Drive aos seus eventos da Agenda. Você pode adicionar o anexo ao criar um evento com events.insert() ou depois como parte de uma atualização, como com events.patch().

As duas partes do processo de anexar um arquivo do Google Drive a um evento são:

  1. Receba o URL do arquivo alternateLink, title e mimeType do 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 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()

Adicionar videoconferências e conferências por telefone a eventos

Você pode associar eventos a conferê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 os detalhes de conferências atuais, além de solicitar a geração de novas conferências. Para permitir a criação e modificação dos detalhes da conferência, defina o parâmetro de solicitação conferenceDataVersion como 1.

Há três tipos de conferenceData compatíveis no momento, conforme indicado pelo conferenceData.conferenceSolution.key.type:

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

Para saber qual tipo de conferência é compatível com uma determinada agenda de um usuário, consulte o conferenceProperties.allowedConferenceSolutionTypes nas coleções calendars e calendarList. Você também pode saber se o usuário prefere que o Hangouts seja criado para todos os eventos criados recentemente verificando a configuração autoAddHangouts na coleção settings.

Além do type, o 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);

Você pode 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ê pode verificar o status da sua solicitação para informar os usuários sobre o que está acontecendo.

Por exemplo, para solicitar a geração de uma conferência para um evento atual:

JavaScript

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

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

A resposta imediata a essa chamada ainda não pode conter o conferenceData totalmente preenchido. Isso é indicado por um código de status pending no campo status. O código de status muda para success depois que as informações da conferê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 discarem.

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

A cópia é ú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 entrem na mesma teleconferência.