Tworzenie zdarzeń

Wyobraź sobie aplikację, która pomaga użytkownikom znajdować najlepsze szlaki turystyczne. Dodając plan wycieczki jako wydarzenie w kalendarzu, użytkownicy mogą łatwiej organizować swoją podróż. Kalendarz Google pomaga im udostępnić plan i przypomina o nim, aby mogli się przygotować bez stresu. Dzięki płynnej integracji usług Google Google Now informuje o godzinie wyjazdu, a Mapy Google pokierują ich na miejsce spotkania na czas.

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

Dodaj wydarzenie

Aby utworzyć zdarzenie, wywołaj metodę events.insert(), która zawiera co najmniej te parametry:

  • calendarId to identyfikator kalendarza, który może być adresem e-mail kalendarza, w którym ma zostać utworzone wydarzenie, lub specjalnym słowem kluczowym 'primary', które będzie 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 internetowym Kalendarza Google (w sekcji „Adres kalendarza”) lub wyszukać go w wynikach wywołania calendarList.list().
  • event to zdarzenie do utworzenia ze wszystkimi niezbędnymi informacjami, takimi jak początek i koniec. Jedyne 2 wymagane pola to pola start i end. Pełny zestaw pól zdarzeń znajdziesz w dokumentacji event.

Aby tworzyć zdarzenia:

  • Ustaw zakres protokołu OAuth na https://www.googleapis.com/auth/calendar, aby mieć uprawnienia do edycji kalendarza użytkownika.
  • Upewnij się, że uwierzytelniony użytkownik ma uprawnienia do zapisu w kalendarzu przy użyciu podanego przez Ciebie identyfikatora calendarId (np. wywołaj calendarList.get() dla calendarId i sprawdź accessRole).

Dodaj metadane zdarzenia

Metadane wydarzenia możesz też dodać podczas tworzenia wydarzenia w kalendarzu. Jeśli podczas tworzenia nie dodasz metadanych, możesz zaktualizować wiele pól za pomocą parametru events.update(), ale niektóre pola, takie jak identyfikator zdarzenia, można ustawić tylko podczas operacji events.insert().

Lokalizacja

Dodanie adresu w polu lokalizacji powoduje włączenie takich funkcji, jak

„godzina wyjazdu” lub wyświetlanie mapy ze wskazówkami dojazdu.

Identyfikator zdarzenia

Podczas tworzenia wydarzenia możesz wygenerować własny identyfikator

który jest zgodny z naszymi wymaganiami dotyczącymi formatu. Dzięki temu możesz synchronizować encje w lokalnej bazie danych ze wydarzeniami z Kalendarza Google. Zapobiega to też tworzeniu duplikatu wydarzeń, jeśli operacja się nie powiedzie po jej pomyślnym wykonaniu w backendzie Kalendarza. Jeśli nie podasz identyfikatora zdarzenia, serwer wygeneruje go za Ciebie. Więcej informacji znajdziesz w dokumentacji identyfikatorów zdarzeń.

Uczestnicy

Utworzone przez Ciebie wydarzenie jest widoczne we wszystkich głównych Kalendarzach Google domeny

uczestników z tym samym identyfikatorem wydarzenia. Jeśli w prośbie o wstawienie ustawisz sendNotifications na true, uczestnicy również otrzymają e-maila z powiadomieniem o wydarzeniu. Więcej informacji znajdziesz w przewodniku po wydarzeniach z wieloma uczestnikami.

Poniższe przykłady pokazują tworzenie zdarzenia i ustawianie jego metadanych:

Przeczytaj

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

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("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/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/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/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, na przykład notatki ze spotkań w Dokumentach, budżety w Arkuszach, prezentacje w Prezentacjach Google i inne odpowiednie pliki z Dysku Google. Ten załącznik możesz dodać podczas tworzenia zdarzenia przy użyciu narzędzia events.insert() lub nowszego w ramach aktualizacji, np. przy użyciu events.patch()

Proces dołączania pliku z Dysku Google do wydarzenia składa się z 2 części:

  1. Pobierz adres URL pliku alternateLink, title i mimeType z zasobu Pliki interfejsu Drive API, zwykle za pomocą metody files.get().
  2. Utwórz lub zaktualizuj zdarzenie z polami attachments ustawionymi w treści żądania i parametrem supportsAttachments ustawionym na true.

Ten przykładowy kod pokazuje, jak zaktualizować istniejące zdarzenie, 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ń

Wydarzenia możesz powiązać z rozmowami w Hangouts i Google Meet, aby umożliwić użytkownikom zdalne spotkania przez rozmowę telefoniczną lub wideo.

Za pomocą pola conferenceData możesz odczytywać, kopiować i usuwać istniejące szczegóły konferencji. W ten sposób możesz też poprosić o generowanie nowych rozmów wideo. Aby umożliwić tworzenie i modyfikowanie szczegółów rozmowy wideo, ustaw parametr żądania conferenceDataVersion na 1.

Obecnie są obsługiwane 3 typy znaczników conferenceData, które są oznaczone etykietą conferenceData.conferenceSolution.key.type:

  1. Hangouts dla klientów indywidualnych (eventHangout)
  2. Klasyczna wersja Hangouts dla Google Workspace użytkowników (wycofana; eventNamedHangout)
  3. Google Meet (hangoutsMeet)

Typ rozmowy wideo jest obsługiwany w przypadku danego kalendarza użytkownika, patrząc na conferenceProperties.allowedConferenceSolutionTypes w kolekcjach calendars i calendarList. Możesz się też dowiedzieć, czy użytkownik woli, by wszystkie nowo utworzone wydarzenia były tworzone w Hangouts. W tym celu sprawdź ustawienie autoAddHangouts w kolekcji settings.

Oprócz type conferenceSolution zawiera też pola name i iconUri, których możesz użyć do przedstawienia rozwiązania do obsługi konferencji, 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);

Aby utworzyć nową rozmowę wideo dla wydarzenia, podaj createRequest z nowo wygenerowanym identyfikatorem requestId, który może być losowym string. Rozmowy wideo są tworzone asynchronicznie, ale zawsze możesz sprawdzić stan swojej prośby, aby użytkownicy wiedzieli, co się dzieje.

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

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

Natychmiastowa odpowiedź na to wywołanie może jeszcze nie zawierać w pełni wypełnionej wartości conferenceData. Jest to wskazywane przez kod stanu pending w polu status. Po uzupełnieniu informacji o rozmowie kod stanu zmieni się na success. Pole entryPoints zawiera informacje o tym, do których identyfikatorów URI połączeń wideo i telefonów użytkownicy mogą dołączać przez telefon.

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

Kopiowanie przydaje się w niektórych sytuacjach. Załóżmy na przykład, że przygotowujesz aplikację rekrutacyjną, która konfiguruje osobne wydarzenia dla kandydata i osoby przeprowadzającej rozmowę – chcesz chronić tożsamość osoby przeprowadzającej rozmowę i upewnić się, że wszyscy jej uczestnicy uczestniczą w tej samej rozmowie konferencyjnej.