Crea eventos

Imagina una aplicación 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 obtienen mucha ayuda para mantenerse organizados automáticamente. El Calendario de Google los ayuda a compartir el plan y lo recuerda para que puedan prepararse sin preocupaciones. Además, gracias a la integración perfecta de los productos de Google, Google Now les indica la hora de salir y Google Maps los dirige al punto de encuentro 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 creará el evento, o bien 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 deseas usar, puedes verificarla en la configuración del calendario de la IU web del Calendario de Google (en la sección "Dirección del calendario") o puedes buscarla en el resultado de la llamada calendarList.list().
• event es el evento que se debe crear con todos los detalles necesarios, como el inicio y el fin. Los únicos dos campos obligatorios son los de start y end. Consulta la referencia de event para ver el conjunto completo de campos de evento.

Para crear eventos correctamente, debes hacer lo siguiente:

• Establece el permiso de OAuth en https://www.googleapis.com/auth/calendar para que tengas 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, si llamas a calendarList.get() para el calendarId y revisas 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 con events.update(). Sin embargo, algunos campos, como el ID del evento, solo se pueden configurar durante una operación events.insert().

Ubicación

Si agregas una dirección en el campo Ubicación, se habilitarán funciones como

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

ID de 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 de tu base de datos local sincronizadas con eventos del Calendario de Google. También se evita la creación de eventos duplicados si la operación falla en algún momento después de que se ejecuta correctamente en el backend del Calendario. Si no se proporciona un ID de evento, el servidor genera uno para ti. Consulta la referencia de ID de eventos para obtener más información.

Participantes

El evento que crees aparecerá en todos los calendarios de Google principales de

los asistentes que incluiste con el mismo ID del 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 de 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:

// 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:"lpage@example.com"},
    &calendar.EventAttendee{Email:"sbrin@example.com"},
  },
}

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)

// 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("lpage@example.com"),
    new EventAttendee().setEmail("sbrin@example.com"),
};
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());

// 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': 'lpage@example.com'},
    {'email': 'sbrin@example.com'}
  ],
  '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);
});

// 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': 'lpage@example.com'},
    {'email': 'sbrin@example.com'},
  ],
  '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);
});

$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' => 'lpage@example.com'),
    array('email' => 'sbrin@example.com'),
  ),
  '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);

# 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': 'lpage@example.com'},
    {'email': 'sbrin@example.com'},
  ],
  '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'))

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: 'lpage@example.com'
    ),
    Google::Apis::CalendarV3::EventAttendee.new(
      email: 'sbrin@example.com'
    )
  ],
  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}"

Cómo 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 en 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, como con events.patch().

Adjuntar un archivo de Google Drive a un evento son los dos pasos siguientes:

1. Obtén la URL del archivo alternateLink, title y mimeType del 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 en true.

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

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

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

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

Agregar conferencias telefónicas y de videoconferencia a los eventos

Puedes asociar eventos con las conferencias de Hangouts y Google Meet para permitir que los 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 la conferencia existente. 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 solicitud conferenceDataVersion en 1.

En la actualidad, se admiten tres tipos de conferenceData, como lo indica 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 reunión es compatible con cualquier calendario de un usuario si consultas conferenceProperties.allowedConferenceSolutionTypes en las colecciones calendars y calendarList. También puedes verificar si el usuario prefiere que se cree Hangouts para todos sus eventos recientemente creados. Para ello, revisa el parámetro de configuración autoAddHangouts de la colección settings.

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:

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 proporcionando un createRequest con un requestId recién generado que pueda ser un string aleatorio. Las conferencias se crean de forma asíncrona, pero siempre puedes verificar el estado de tu solicitud para informar a los usuarios lo que sucede.

Por ejemplo, si quieres solicitar que se genere una conferencia para un evento existente, sigue estos pasos:

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 objeto conferenceData propagado por completo. Esto se indica con un código de estado pending en el campo status. El código de estado cambia a success cuando se completa la información de la conferencia. El campo entryPoints contiene información sobre los URI de video y teléfono disponibles para que los usuarios llamen para entrar a la reunión.

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

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