Crea eventos

Imagina una aplicación que ayude a los usuarios a encontrar las mejores rutas de senderismo. Al agregar el un plan de senderismo como un evento de calendario, los usuarios obtienen mucha ayuda para mantenerse organizada de forma automática. El Calendario de Google los ayuda a compartir el plan y lo recuerda para que puedan prepararse sin estrés. Además, gracias a integración perfecta de los productos de Google, Google Now les indica el momento para y Google Maps los dirigirá al punto de encuentro a tiempo.

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

Agregar un evento

Para crear un evento, llama al events.insert() que 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 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 comprobarlo en la configuración del calendario de la página web de Calendario de Google IU (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 finalizan. Los únicos dos campos obligatorios son los de start y end. Consulta la Referencia de event para el conjunto completo de eventos .

Para crear eventos correctamente, debes hacer lo siguiente:

• Establece el permiso de OAuth en https://www.googleapis.com/auth/calendar para que tienes 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 calendarId y verificando accessRole).

Agrega metadatos de eventos

De manera opcional, puedes agregar metadatos de eventos cuando creas un evento de calendario. Si puedes elegir no agregar metadatos durante la creación, puedes actualizar muchos campos con el 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 indicaciones.

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 en tu base de datos local, y sincronizada 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 se ejecuta correctamente en el backend del Calendario. Si la respuesta es no si proporcionas un ID de evento, el servidor generará uno para ti. Ver el ID del evento referencia 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 estableces sendNotifications a true en tu solicitud de inserción, los asistentes también recibirán una notificación por correo electrónico sobre el evento. Consulta los eventos con para varios asistentes 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 Google Drive. como notas de la reunión en Documentos, presupuestos en Hojas de cálculo, presentaciones en Presentaciones o cualquier otro archivos relevantes de Google Drive a tus eventos del calendario. Puedes agregar un archivo adjunto cuando creas un evento con events.insert() o una versión posterior como parte de un actualización, como con events.patch()

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

1. Obtén la URL del archivo alternateLink, title y mimeType de 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 la solicitud. y el parámetro supportsAttachments establecido en true.

En el siguiente ejemplo de código, se muestra cómo actualizar un evento existente para agregarlo un archivo 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 Hangouts y reuniones de Google Meet para Permiten que los usuarios se reúnan de forma remota a través de una llamada telefónica o una videollamada.

El campo conferenceData solo usarse para leer, copiar y borrar los detalles de la conferencia existente; también puede ser para solicitar la generación de nuevas conferencias. Para permitir la creación y modificación de los detalles de la conferencia, establecer la solicitud conferenceDataVersion parámetro en 1.

En la actualidad, se admiten tres tipos de conferenceData, como se indica en la conferenceData.conferenceSolution.key.type

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

Puedes aprender qué tipo de conferencia es compatible con cualquier calendario determinado de un usuario consultando conferenceProperties.allowedConferenceSolutionTypes en el calendars y calendarList. También puedes averiguar si el usuario prefiere que los Hangouts se creen para todas sus los eventos creados, verificando el parámetro autoAddHangouts en el settings colección.

Además de type, conferenceSolution también proporciona name y el Campos 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 nueva conferencia para un evento proporcionando un createRequest con Un requestId recién generado que puede ser un string aleatorio. Las conferencias son se crean de forma asíncrona, pero siempre puedes verificar el estado de tu solicitud para 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 valor conferenceData; esto se indica con un código de estado de pending en el estado . El código de estado cambia a success luego de que la información de la conferencia se se complete. El campo entryPoints contiene información sobre qué video y los URI de teléfono están disponibles para que los usuarios llamen para entrar a la reunión.

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

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