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ępniać plan i przypomina o nim, dzięki czemu mogą się bezstresowo przygotować. 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. Może to być adres e-mail kalendarza, w którym ma zostać utworzone wydarzenie, lub specjalne słowo kluczowe 'primary', które użyje 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 utworzyć zdarzenia, musisz:

  • 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 zdecydujesz się nie dodawać metadanych podczas tworzenia, możesz zaktualizować wiele pól za pomocą funkcji events.update(). Niektóre pola, takie jak identyfikator zdarzenia, można jednak ustawić tylko podczas operacji events.insert().

Lokalizacja

Dodanie adresu w polu lokalizacji umożliwia korzystanie z takich funkcji jak

„Czas wyjazdu” lub wyświetlanie mapy z trasą.

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ść elementów w lokalnej bazie danych z 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 dotyczącej 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 żądaniu wstawienia sendNotifications zmienisz na true, uczestnicy otrzymają e-maila z powiadomieniem o Twoim wydarzeniu. Więcej informacji znajdziesz w przewodniku Zdarzenia z większą liczbą uczestników.

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 plików 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ń

Możesz powiązać wydarzenia z Hangouts i konferencjami Google Meet, aby umożliwić użytkownikom prowadzenie zdalnych spotkań za pomocą rozmowy telefonicznej 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 konferencji, ustaw parametr conferenceDataVersion żądania na 1.

Obecnie obsługiwane są 3 rodzaje conferenceData, oznaczone jako conferenceData.conferenceSolution.key.type:

  1. Hangouts dla użytkowników indywidualnych (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 kolekcjach 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);

Nową konferencję dla wydarzenia możesz utworzyć, podając createRequest z nowo wygenerowanym 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 do nawiązywania połączeń.

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 tworzy 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.