Tworzenie zdarzeń

Wyobraź sobie aplikację, która pomaga użytkownikom znaleźć najlepsze trasy piesze. Dodając plan wycieczki jako wydarzenie w kalendarzu, użytkownicy mogą automatycznie zachować porządek. Kalendarz Google pomaga im udostępniać plan i przypomina o nim, dzięki czemu mogą się przygotować bez stresu. Dzięki płynnej integracji usług Google Mapy Google kierują ich na miejsce spotkania na czas.

Z tego artykułu dowiesz się, jak tworzyć wydarzenia w kalendarzu i dodawać je do kalendarzy użytkowników.

Dodaj wydarzenie

Aby utworzyć wydarzenie, wywołaj metodę events.insert, podając co najmniej te parametry:

  • calendarId to identyfikator kalendarza. Może to być adres e-mail kalendarza, w którym ma zostać utworzone wydarzenie, lub specjalne słowo kluczowe 'primary', które używa kalendarza głównego zalogowanego użytkownika. Jeśli nie znasz adresu e-mail kalendarza, którego chcesz użyć, możesz go sprawdzić w ustawieniach kalendarza w interfejsie Kalendarza (w sekcji „Adres kalendarza”) lub poszukać go w wyniku wywołania calendarList.list.
  • event to wydarzenie, które ma zostać utworzone, ze wszystkimi niezbędnymi szczegółami, takimi jak data i godzina rozpoczęcia oraz zakończenia. Jedynymi wymaganymi polami są start i end. Pełny zestaw pól wydarzenia znajdziesz w dokumentacji zasobu Events.

Aby utworzyć wydarzenia:

  • Ustaw zakres OAuth na https://www.googleapis.com/auth/calendar, aby mieć dostęp do edycji kalendarza użytkownika.
  • Sprawdź, czy uwierzytelniony użytkownik ma dostęp do zapisu w kalendarzu z podanym calendarId (na przykład wywołując calendarList.get dla calendarId i sprawdzając accessRole).

Dodawanie metadanych wydarzenia

Podczas tworzenia wydarzenia w kalendarzu możesz opcjonalnie dodać metadane wydarzenia. Jeśli nie dodasz metadanych podczas tworzenia, możesz zaktualizować wiele pól za pomocą metody events.update. Niektóre pola, np. identyfikator wydarzenia, można jednak ustawić tylko podczas operacji events.insert.

Lokalizacja
Dodanie adresu w polu lokalizacji umożliwia korzystanie z funkcji takich jak „godzina wyjazdu” czy wyświetlanie mapy ze wskazówkami dojazdu.
Identyfikator zdarzenia
Podczas tworzenia wydarzenia możesz wygenerować własny identyfikator wydarzenia, który jest zgodny z wymaganiami dotyczącymi formatu. Dzięki temu możesz synchronizować encje w lokalnej bazie danych z wydarzeniami w Kalendarzu. Zapobiega to też tworzeniu duplikatów wydarzeń, jeśli operacja nie powiedzie się w pewnym momencie po pomyślnym wykonaniu w backendzie Kalendarza. Jeśli nie podasz identyfikatora wydarzenia, serwer wygeneruje go. Więcej informacji znajdziesz w dokumentacji identyfikatora wydarzenia.
Uczestnicy
Utworzone przez Ciebie wydarzenie pojawi się we wszystkich kalendarzach głównych uczestników, których uwzględniasz, z tym samym identyfikatorem wydarzenia. Jeśli w żądaniu wstawienia ustawisz sendUpdates na "all" lub "externalOnly", odpowiedni uczestnicy otrzymają e-maila z powiadomieniem o wydarzeniu. Więcej informacji znajdziesz w artykule Wydarzenia z wieloma uczestnikami.

Poniższe przykłady pokazują, jak utworzyć wydarzenie i ustawić jego metadane:

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:"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)

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

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

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

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

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': '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'))

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: '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}"

Dodawanie załączników z Dysku do wydarzeń

Do wydarzeń w kalendarzu możesz dołączać pliki z Dysku Google, takie jak notatki ze spotkań w Dokumentach Google, budżety w Arkuszach Google, prezentacje w Prezentacjach Google lub inne odpowiednie pliki z Dysku. Załącznik możesz dodać podczas tworzenia wydarzenia za pomocą metody events.insert lub później w ramach aktualizacji, np. za pomocą metody events.patch.

Dołączenie pliku z Dysku do wydarzenia składa się z 2 części:

  1. Pobierz adres URL pliku alternateLink, title i mimeType z zasobu Files interfejsu Google Drive API, zwykle za pomocą metody files.get.
  2. Utwórz lub zaktualizuj wydarzenie, ustawiając pola attachments w treści żądania i parametr supportsAttachments na true.

Poniższy przykład kodu pokazuje, jak zaktualizować istniejące wydarzenie, aby dodać załącznik:

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

Dodawanie rozmów wideo i telefonicznych do wydarzeń

Możesz powiązać wydarzenia z konferencjami w Google Meet, aby umożliwić użytkownikom spotkania zdalne przez połączenie telefoniczne lub rozmowę wideo.

Pole conferenceData umożliwia odczytywanie, kopiowanie i czyszczenie istniejących szczegółów konferencji oraz generowanie nowych konferencji. Aby umożliwić tworzenie i modyfikowanie szczegółów konferencji, ustaw parametr żądania conferenceDataVersion na 1.

Obsługiwane są te typy konferencji, które są oznaczone przez conferenceData.conferenceSolution.key.type:

  1. Google Meet (hangoutsMeet)

Możesz sprawdzić, który typ konferencji jest obsługiwany w danym kalendarzu użytkownika, sprawdzając conferenceProperties.allowedConferenceSolutionTypes w kolekcjach calendars i calendarList.

Oprócz type element conferenceSolution zawiera też pola name i iconUri, których możesz użyć do reprezentowania rozwiązania konferencyjnego, jak pokazano poniżej:

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

Możesz utworzyć nową konferencję na potrzeby wydarzenia, podając createRequest z nowo wygenerowanym requestId jako ciągiem losowym. Konferencje są tworzone asynchronicznie, ale zawsze możesz sprawdzić stan żądania, aby poinformować użytkowników o tym, co się dzieje.

Aby na przykład poprosić o wygenerowanie konferencji na potrzeby istniejącego wydarzenia:

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

Natychmiastowa odpowiedź na to wywołanie może jeszcze nie zawierać w pełni wypełnionego conferenceData; pole stanu zawiera pending. Po wypełnieniu informacji o konferencji kod stanu zmieni się na success. Pole entryPoints zawiera informacje o tym, które adresy URI rozmów wideo i telefonicznych są dostępne dla użytkowników.

Jeśli chcesz zaplanować kilka wydarzeń w Kalendarzu z tymi samymi szczegółami konferencji, możesz skopiować całe pole conferenceData z jednego wydarzenia do drugiego.

Kopiowanie jest przydatne w niektórych sytuacjach. Załóżmy na przykład, że tworzysz aplikację do rekrutacji, która konfiguruje osobne wydarzenia dla kandydata i osoby przeprowadzającej rozmowę kwalifikacyjną. Chcesz chronić tożsamość osoby przeprowadzającej rozmowę, ale też mieć pewność, że wszyscy uczestnicy dołączą do tego samego połączenia konferencyjnego.