Tworzenie zdarzeń

Wyobraź sobie aplikację, która pomaga użytkownikom znaleźć najlepsze szlaki turystyczne. Dodanie planu wycieczki jako wydarzenia w kalendarzu pomaga użytkownikom w automatycznym utrzymywaniu porządku. 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 ich o godzinie wyjazdu, a Mapy Google kierują na czas na miejsce spotkania.

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

Dodaj wydarzenie

Aby utworzyć zdarzenie, wywołaj metodę events.insert(), podając 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 w wyniku wywołania funkcji calendarList.list().
  • event to zdarzenie, które należy utworzyć ze wszystkimi niezbędnymi szczegółami, takimi jak początek i koniec. Jedynymi wymaganymi polami są czasy start i end. Pełny zestaw pól zdarzenia znajdziesz w dokumentacji event.

Aby tworzyć zdarzenia:

  • Ustaw zakres uprawnień OAuth na https://www.googleapis.com/auth/calendar, aby mieć uprawnienia do edycji w kalendarzu użytkownika.
  • Upewnij się, że uwierzytelniony użytkownik ma dostęp do zapisu w kalendarzu z podanym przez Ciebie identyfikatorem calendarId (na przykład przez wywołanie funkcji calendarList.get() dla calendarId i sprawdzenie wartości accessRole).

Dodawanie metadanych zdarzenia

Podczas tworzenia wydarzenia w kalendarzu możesz opcjonalnie dodać metadane wydarzenia. 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 zdarzenia możesz wygenerować własny identyfikator zdarzenia.

który jest zgodny z naszymi wymaganiami dotyczącymi formatu. Dzięki temu możesz utrzymywać zgodność między elementami w lokalnej bazie danych a wydarzeniami w Kalendarzu Google. Zapobiega też tworzeniu zduplikowanych wydarzeń, jeśli operacja nie powiedzie się w jakimś momencie po jej pomyślnym wykonaniu w backendzie Kalendarza. Jeśli nie podasz identyfikatora zdarzenia, serwer wygeneruje go samodzielnie. Więcej informacji znajdziesz w dokumentacji identyfikatorów zdarzeń.

Uczestnicy

Utworzone wydarzenie pojawi się we wszystkich głównych kalendarzach Google na koncie

uczestników, których dodałeś/dodałaś 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.

W poniższych przykładach pokazano, jak utworzyć zdarzenie i ustawić jego metadane:

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, takie jak notatki z zebrania w Dokumentach, budżety w Arkuszach, prezentacje w Prezentacjach lub inne odpowiednie pliki z Dysku Google. Załącznik możesz dodać podczas tworzenia wydarzenia w wersji events.insert() lub nowszej jako część aktualizacji, np. events.patch()

Dołączanie 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, zazwyczaj za pomocą metody files.get().
  2. Utwórz lub zaktualizuj zdarzenie, ustawiając w ciele żądania pola attachments, a także parametr supportsAttachments na true.

Ten przykładowy kod pokazuje, jak zaktualizować istniejące zdarzenie, aby dodać do niego 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.

Pola conferenceData możesz używać do odczytywania, kopiowania i czyszczenia istniejących szczegółów konferencji. Możesz też używać go do żądania wygenerowania nowych konferencji. 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 konsumentów (eventHangout)
  2. Klasyczna wersja Hangouts dla użytkowników Google Workspace (wycofana; eventNamedHangout)
  3. Google Meet (hangoutsMeet)

Aby dowiedzieć się, który typ konferencji jest obsługiwany w danym kalendarzu użytkownika, sprawdź wartość conferenceProperties.allowedConferenceSolutionTypes w kolekcji calendars i calendarList. Możesz też sprawdzić, czy użytkownik preferuje tworzenie Hangouts dla wszystkich nowo utworzonych wydarzeń. Aby to zrobić, sprawdź ustawienie autoAddHangouts w kolekcji settings.

Oprócz pola type w polu conferenceSolution znajdują się też pola name i iconUri, które możesz wykorzystać 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);

Aby utworzyć nową konferencję dla wydarzenia, podaj createRequest z nowo wygenerowanym identyfikatorem requestId, który może być losowym string. Konferencje są tworzone asynchronicznie, ale zawsze możesz sprawdzić stan swojej prośby, aby poinformować użytkowników o tym, 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);
});

Bezpośrednia odpowiedź na to wywołanie może nie zawierać w pełni wypełnionego pola conferenceData. Wskazuje na to kod stanu pending w polu status. Po wypełnieniu informacji o konferencji kod stanu zmieni się na success. Pole entryPoints zawiera informacje o tym, które identyfikatory URI wideo i telefonu 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ły 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 zdarzenia dla kandydata i rozmówcy. Chcesz chronić tożsamość rozmówcy, ale jednocześnie musisz mieć pewność, że wszyscy uczestnicy dołączają do tego samego połączenia konferencyjnego.