Criar eventos

Imagine um app que ajuda os usuários a encontrar as melhores rotas para caminhadas. Ao adicionar o parâmetro plano de caminhada como um evento do calendário, os usuários recebem muita ajuda para manter são organizados automaticamente. O Google Agenda os ajuda a compartilhar o plano lembrar a pessoa sobre isso para que ela possa se preparar sem estresse. Além disso, graças à integração perfeita dos produtos do Google, o Google Now dá um ping sobre o tempo para sair e o Google Maps direcioná-los para o local a tempo.

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

Adicionar um evento

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

• calendarId é o identificador da agenda e pode ser o endereço de e-mail da agenda na qual criar o evento ou uma palavra-chave especial 'primary', que vai usar a agenda principal do usuário conectado. Se não souber o endereço de e-mail da agenda que quer usar, pode verificá-la nas configurações da agenda no Google Agenda na Web. interface do usuário (na seção "Endereço da agenda") ou procure por ela. no resultado chamada calendarList.list().
• event é o evento a ser criado com todos os detalhes necessários, como início e fim. Os únicos dois campos obrigatórios são start e end vezes. Consulte a Referência de event para o conjunto completo de eventos campos.
  Especificar eventos com marcação de tempo usando a 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 que você tem acesso para editar a agenda do usuário.
• Verifique se o usuário autenticado tem acesso de gravação na agenda com a calendarId que você forneceu (por exemplo, chamando calendarList.get() para o calendarId e verificando o accessRole).

Adicionar metadados de eventos

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

Local

Adicionar um endereço no campo "Local" ativa recursos como

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

ID do evento

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

que esteja em conformidade com nossos requisitos de formato. Isso permite que você mantenha entidades no seu banco de dados local sincronizado com os eventos do Google Agenda. Ela também evita a criação de eventos duplicados se a operação falhar em algum momento após ela será executada no back-end do Agenda. Em caso negativo ID do evento for fornecido, o servidor gerará um para você. Veja o ID do evento referência para mais informações.

Participantes

O evento que você criar aparecerá em todas as agendas principais do Google Agenda de

os participantes que você incluiu com o mesmo ID de evento. Se você definir sendNotifications a true na sua solicitação de inserção, os participantes vão receber uma notificação por e-mail do seu evento. Veja os eventos com para vários participantes mais informações.

Os exemplos a seguir demonstram a criação de um evento e a configuração dos metadados:

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 o Google Drive como atas de reunião no app Documentos, orçamentos no Planilhas, apresentações no Apresentações ou qualquer outro arquivos relevantes do Google Drive aos eventos da agenda. Você pode adicionar o método ao criar um evento com o events.insert() ou posterior como parte de uma Atualização, como em events.patch()

As duas partes necessárias para anexar um arquivo do Google Drive a um evento são:

1. Consiga o URL, title e mimeType do arquivo alternateLink no o recurso de arquivos da API Drive, geralmente com o método files.get().
2. Crie ou atualize um evento com os campos attachments definidos na solicitação. Corpo do texto e o parâmetro supportsAttachments definidos 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 o evento modificações ao adicionar suporte a anexos em seu app existente que armazena eventos locais. Se você não executar uma sincronização primeiro, poderá remover acidentalmente anexos dos eventos do usuário.

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

É possível associar eventos Hangouts e Conferências do Google Meet para permitir que seus usuários se reúnam remotamente por uma chamada telefônica ou videochamada.

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

Há três tipos de conferenceData com suporte no momento, 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)

Você pode saber que tipo de videoconferência é compatível com a agenda de uma usuário conferindo o conferenceProperties.allowedConferenceSolutionTypes no calendars e Coleções do calendarList. Você também pode descobrir se o usuário prefere que o Hangouts seja criado para todos os criou eventos verificando a configuração autoAddHangouts na settings.

Além do type, o conferenceSolution também fornece o name e o Campos 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 criado de maneira assíncrona, mas você sempre pode verificar o status de sua solicitação para informe os usuários sobre o que está acontecendo.

Por exemplo, para solicitar a geração de conferência 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 nome de domínio conferenceData isso é indicado por um código de status pending no status . O código de status mudará para success depois que as informações da videoconferência forem preenchida. O campo entryPoints contém informações sobre qual vídeo e URIs de telefone estejam disponíveis para que seus usuários liguem para a reunião.

Se você quiser programar vários eventos do Google Agenda com o mesmo detalhes da conferência, você poderá copiar conferenceData de um evento para o para outra.

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 entrevistador, você quer proteger a identidade dele, mas quer que todos os participantes entrem na mesma conferência.

Importante: é necessário fazer uma sincronização completa. de todos os eventos antes de ativar o suporte a dados de conferência (por meio da configuração do o parâmetro de solicitação conferenceDataVersion como 1 para modificações de evento) quando adicionar suporte para conferências ao seu app atual que armazena eventos localmente. Se você não executar uma sincronização primeiro, poderá remover acidentalmente conferências de usuários eventos.