Crear eventos

Imagina una app que ayude a los usuarios a encontrar las mejores rutas de senderismo. Si agregas el plan de senderismo como un evento de calendario, los usuarios obtendrán mucha ayuda para mantenerse organizados automáticamente. El Calendario de Google los ayuda a compartir el plan y les recuerda para que puedan prepararse sin estrés. Además, gracias a la integración continua de los productos de Google, Google Now les informa la hora de salir y Google Maps los dirige al lugar de reunión a tiempo.

En este artículo, se explica cómo crear eventos de calendario y agregarlos a los calendarios de tus usuarios.

Agregar un evento

Para crear un evento, llama al método events.insert() y proporciona, al menos, estos parámetros:

• calendarId es el identificador del calendario y puede ser la dirección de correo electrónico del calendario en el que se crea el evento o una palabra clave especial 'primary' que usará el calendario principal del usuario que accedió. Si no conoces la dirección de correo electrónico del calendario que quieres usar, puedes consultarla en la configuración del calendario de la IU web del Calendario de Google (en la sección "Dirección del calendario") o buscarla en el resultado de la llamada a calendarList.list().
• event es el evento que se crea con todos los detalles necesarios, como el inicio y la finalización. Los únicos dos campos obligatorios son los horarios start y end. Consulta la referencia de event para ver el conjunto completo de campos de eventos.
  Especifica eventos temporizados con los campos start.dateTime y end.dateTime. Para eventos de todo el día, usa start.date y end.date en su lugar.

Para crear eventos correctamente, debes hacer lo siguiente:

• Establece el alcance de OAuth en https://www.googleapis.com/auth/calendar para tener acceso de edición al calendario del usuario.
• Asegúrate de que el usuario autenticado tenga acceso de escritura al calendario con el calendarId que proporcionaste (por ejemplo, llamando a calendarList.get() para el calendarId y verificando el accessRole).

Agrega metadatos de eventos

De manera opcional, puedes agregar metadatos de eventos cuando creas un evento de calendario. Si eliges no agregar metadatos durante la creación, puedes actualizar muchos campos mediante events.update(). Sin embargo, algunos campos, como el ID del evento, solo se pueden configurar durante una operación events.insert().

Ubicación

Agregar una dirección en el campo de ubicación habilita funciones como

"hora de salir" o mostrar un mapa con instrucciones sobre cómo llegar.

ID del evento

Cuando creas un evento, puedes elegir generar tu propio ID del evento.

que cumpla con nuestros requisitos de formato. Esto te permite mantener las entidades en tu base de datos local sincronizadas con los eventos del Calendario de Google. También evita la creación de eventos duplicados si la operación falla en algún momento después de que se ejecute de forma correcta en el backend del Calendario. Si no se proporciona un ID de evento, el servidor genera uno por ti. Consulta la referencia del ID del evento para obtener más información.

Participantes

El evento que creas aparece en todos los calendarios de Google principales de

los asistentes que incluiste con el mismo ID de evento. Si configuras sendNotifications como true en la solicitud de inserción, los asistentes también recibirán una notificación por correo electrónico del evento. Consulta la guía sobre eventos con varios asistentes para obtener más información.

En los siguientes ejemplos, se muestra cómo crear un evento y configurar sus metadatos:

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

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

$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}"

Agregar archivos adjuntos de Drive a los eventos

Puedes adjuntar archivos de Google Drive, como notas de reuniones en Documentos, presupuestos en Hojas de cálculo, Presentaciones o cualquier otro archivo relevante de Google Drive a tus eventos de calendario. Puedes agregar el adjunto cuando creas un evento con events.insert() o una versión posterior como parte de una actualización, por ejemplo, con events.patch().

Las dos partes de adjuntar un archivo de Google Drive a un evento son las siguientes:

1. Obtén la URL alternateLink, title y mimeType del archivo desde el recurso de archivos de la API de Drive, por lo general, con el método files.get().
2. Crea o actualiza un evento con los campos attachments configurados en el cuerpo de la solicitud y el parámetro supportsAttachments configurado como true.

En el siguiente ejemplo de código, se muestra cómo actualizar un evento existente para agregar un archivo adjunto:

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: Debes realizar una sincronización completa de todos los eventos antes de habilitar el parámetro supportsAttachments para las modificaciones de eventos cuando agregas compatibilidad con adjuntos en tu app existente que almacena eventos de forma local. Si no realizas una sincronización primero, es posible que quites los archivos adjuntos existentes de los eventos del usuario por error.

Agrega conferencias telefónicas y de video a los eventos

Puedes asociar eventos con conferencias de Hangouts y Google Meet para permitir que tus usuarios se reúnan de forma remota mediante una llamada telefónica o una videollamada.

El campo conferenceData se puede usar para leer, copiar y borrar los detalles de las conferencias existentes. También se puede usar para solicitar la generación de conferencias nuevas. Para permitir la creación y la modificación de los detalles de la conferencia, establece el parámetro de la solicitud conferenceDataVersion en 1.

Actualmente, se admiten tres tipos de conferenceData, como se indica en conferenceData.conferenceSolution.key.type:

1. Hangouts para consumidores (eventHangout)
2. Versión clásica de Hangouts para Google Workspace usuarios (obsoleta; eventNamedHangout)
3. Google Meet (hangoutsMeet)

Puedes saber qué tipo de conferencia es compatible con el calendario de un usuario determinado si consultas conferenceProperties.allowedConferenceSolutionTypes en las colecciones calendars y calendarList. También puedes verificar el parámetro de configuración autoAddHangouts en la colección settings para saber si el usuario prefiere que se creen Hangouts para todos los eventos recién creados.

Además de type, conferenceSolution también proporciona los campos name y iconUri que puedes usar para representar la solución de conferencia, como se muestra a continuación:

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);

Puedes crear una conferencia nueva para un evento si proporcionas un createRequest con un requestId recién generado que puede ser un string aleatorio. Las conferencias se crean de forma asíncrona, pero siempre puedes verificar el estado de la solicitud para que los usuarios sepan lo que sucede.

Por ejemplo, a fin de solicitar la generación de conferencia para un evento existente, sigue estos pasos:

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);
});

Es posible que la respuesta inmediata a esta llamada aún no contenga el conferenceData completamente propagado. Esto se indica con un código de estado de pending en el campo status. El código de estado cambia a success después de que se propaga la información de la conferencia. El campo entryPoints contiene información sobre qué URI de video y teléfono están disponibles para que los usuarios llamen para entrar a la reunión.

Si deseas programar varios eventos de Calendario con los mismos detalles de reunión, puedes copiar la conferenceData completa de un evento a otro.

La copia es útil en ciertas situaciones. Por ejemplo, supongamos que estás desarrollando una aplicación de reclutamiento que configura eventos separados para el candidato y el entrevistador; deseas proteger la identidad del entrevistador, pero también deseas asegurarte de que todos los participantes se unan a la misma conferencia telefónica.

Importante: Debes realizar una sincronización completa de todos los eventos antes de habilitar la compatibilidad con los datos de conferencia (configurando el parámetro de solicitud conferenceDataVersion en 1 para las modificaciones de eventos) cuando agregues compatibilidad con conferencias a tu app existente que almacena eventos a nivel local. Si no lo haces, es posible que quites de forma involuntaria las conferencias existentes de los eventos de los usuarios.