Tekoälyagentit · Oppitunti

Kalenteritapahtumien luominen ja hakeminen

Google Calendar API: tapahtumien luettelointi, kokousten luominen ja muistutusten asettaminen

Oppitunti 3/413 vaihetta

Kalenteritapahtumien luominen ja hakeminen on ilmainen Tekoälyagentit-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Tekoälyagentit-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Tekoälyagentit-kurssilla on yhteensä 4 oppituntia.

Google Calendar API:n yleiskatsaus

Google Calendar API:n avulla agentit voivat lukea, luoda, päivittää ja poistaa kalenteritapahtumia. Se käyttää samaa Google OAuth -todennusta kuin Gmail. Ensisijainen resurssi on Event-objekti, ja tapahtumat kuuluvat Calendar-kalenteriin. 'primary'-kalenteritunnus viittaa todennetun käyttäjän pääkalenteriin.

from googleapiclient.discovery import build

# Build calendar service (same credentials as Gmail)
calendar = build(
    'calendar', 'v3',
    credentials=creds,
    cache_discovery=False
)

# Get a list of the user's calendars
cal_list = calendar.calendarList().list().execute()
for cal in cal_list.get('items', []):
    print(f'{cal["summary"]}: {cal["id"]}')
    # Primary calendar ID is the user's email address

Tulevien tapahtumien luetteleminen

Noutakaa tapahtumat käyttämällä kohdetta service.events().list(). Parametrit timeMin ja timeMax suodattavat tapahtumat aikavälin perusteella. Käyttäkää aina RFC 3339 -muotoisia päivämäärä- ja aikamerkkijonoja aikavyöhykepoikkeamalla. Asettakaa singleEvents=True, jotta toistuvat tapahtumat laajennetaan yksittäisiksi esiintymiksi.

import datetime
import pytz

def get_upcoming_events(service, calendar_id='primary', max_results=10):
    now = datetime.datetime.now(pytz.utc)
    time_min = now.isoformat()  # RFC 3339 format
    time_max = (now + datetime.timedelta(days=7)).isoformat()

    events_result = service.events().list(
        calendarId=calendar_id,
        timeMin=time_min,
        timeMax=time_max,
        maxResults=max_results,
        singleEvents=True,      # expand recurring events
        orderBy='startTime'
    ).execute()

    events = events_result.get('items', [])
    for event in events:
        start = event['start'].get('dateTime', event['start'].get('date'))
        print(f'{start}: {event["summary"]}')

    return events

Tapahtuman alku- ja päättymisaikojen jäsentäminen

Kalenteritapahtumissa käytetään kahdentyyppisiä aikoja: dateTime tarkoittaa tavallisten tapahtumien tiettyä aikaa aikavyöhykkeineen, kun taas date sisältää koko päivän tapahtumista vain päivämäärän ilman kellonaikaa. Tarkistakaa aina ennen jäsentämistä, kumpi kenttä on käytettävissä.

from datetime import datetime
import re

def parse_event_time(time_dict):
    if 'dateTime' in time_dict:
        # Parse RFC 3339 datetime: '2026-05-29T14:00:00+03:00'
        dt_str = time_dict['dateTime']
        # Python 3.7+ fromisoformat handles this
        return datetime.fromisoformat(dt_str), False  # not all-day
    else:
        # All-day event: '2026-05-29'
        date_str = time_dict['date']
        return datetime.strptime(date_str, '%Y-%m-%d'), True  # all-day

for event in events:
    start_dt, is_all_day = parse_event_time(event['start'])
    end_dt, _ = parse_event_time(event['end'])
    duration = end_dt - start_dt if not is_all_day else None
    print(f'{event["summary"]}: {start_dt.strftime("%H:%M")} '
          f'({"all-day" if is_all_day else str(duration)})')

Yksinkertaisen tapahtuman luominen

Luokaa uusi tapahtuma käyttämällä kohdetta service.events().insert(). Pakolliset vähimmäiskentät ovat summary (otsikko), start ja end. Aikojen on oltava RFC 3339 -muodossa ja sisällettävä aikavyöhyke. Alku- ja loppuajan timeZone-kenttä määrittää aikavyöhykkeen nimen.

def create_event(service, title, start_datetime, end_datetime,
                 description='', timezone='UTC', calendar_id='primary'):
    event = {
        'summary': title,
        'description': description,
        'start': {
            'dateTime': start_datetime.isoformat(),
            'timeZone': timezone
        },
        'end': {
            'dateTime': end_datetime.isoformat(),
            'timeZone': timezone
        }
    }

    created = service.events().insert(
        calendarId=calendar_id,
        body=event
    ).execute()

    print(f'Event created: {created["summary"]}')
    print(f'Event ID: {created["id"]}')
    print(f'Link: {created["htmlLink"]}')
    return created

# --- demo: minimal stand-in for the Calendar API's service object ---
import datetime

class _Exec:
    def __init__(self, result):
        self._result = result
    def execute(self):
        return self._result

class _FakeEvents:
    def insert(self, calendarId, body):
        return _Exec({**body, 'id': 'evt_123',
                       'htmlLink': 'https://calendar.google.com/event?eid=evt_123'})

class _FakeService:
    def events(self):
        return _FakeEvents()

service = _FakeService()
start = datetime.datetime(2026, 8, 10, 9, 0)
end = start + datetime.timedelta(hours=1)
create_event(service, 'Team Sync', start, end, description='Weekly sync')

Osallistujien lisääminen tapahtumiin

Lisätkää osallistujat tapahtumaan sisällyttämällä siihen attendees-lista sähköpostiosoitteineen. Asettakaa sendUpdates='all', jotta Google Calendar lähettää kutsut automaattisesti kaikille osallistujille. Ilmoittakaa vain ulkoisille vieraille käyttämällä arvoa 'externalOnly'.

import datetime

def schedule_meeting(service, title, start_iso, duration_minutes,
                     attendees, description=''):
    start = datetime.datetime.fromisoformat(start_iso)
    end = start + datetime.timedelta(minutes=duration_minutes)

    event = {
        'summary': title,
        'description': description,
        'start': {'dateTime': start.isoformat(), 'timeZone': 'UTC'},
        'end': {'dateTime': end.isoformat(), 'timeZone': 'UTC'},
        'attendees': [
            {'email': email} for email in attendees
        ],
        'conferenceData': {
            'createRequest': {'requestId': f'meet-{start.timestamp()}'}
        }  # creates a Google Meet link
    }

    created = service.events().insert(
        calendarId='primary',
        body=event,
        sendUpdates='all',           # send invites
        conferenceDataVersion=1      # enable Meet link creation
    ).execute()
    return created

# --- demo: minimal stand-in for the Calendar API's service object ---
class _Exec:
    def __init__(self, result):
        self._result = result
    def execute(self):
        return self._result

class _FakeEvents:
    def insert(self, calendarId, body, sendUpdates=None, conferenceDataVersion=None):
        return _Exec({**body, 'id': 'evt_456'})

class _FakeService:
    def events(self):
        return _FakeEvents()

service = _FakeService()
created = schedule_meeting(
    service, 'Sprint Planning', '2026-08-11T10:00:00', 30,
    attendees=['alice@example.com', 'bob@example.com']
)
print(f'Meeting scheduled: {created["summary"]}')
print(f'Attendees: {[a["email"] for a in created["attendees"]]}')

Muistutusten lisääminen tapahtumiin

Tapahtumilla voi olla muistutuksia eli ennen tapahtumaa lähetettäviä ilmoituksia. Käyttäkää arvoa 'popup' selaimen tai sovelluksen sisäisiin ilmoituksiin ja arvoa 'email' sähköpostimuistutuksiin. Asettakaa useDefault: False, jos haluatte ohittaa kalenterin oletukset mukautetuilla ajoituksilla.

def create_event_with_reminders(service, title, start_iso, end_iso):
    event = {
        'summary': title,
        'start': {'dateTime': start_iso, 'timeZone': 'UTC'},
        'end': {'dateTime': end_iso, 'timeZone': 'UTC'},
        'reminders': {
            'useDefault': False,
            'overrides': [
                {'method': 'email', 'minutes': 24 * 60},   # 1 day before
                {'method': 'popup', 'minutes': 30},         # 30 min before
                {'method': 'popup', 'minutes': 10}          # 10 min before
            ]
        }
    }

    return service.events().insert(
        calendarId='primary',
        body=event
    ).execute()

# --- demo: minimal stand-in for the Calendar API's service object ---
class _Exec:
    def __init__(self, result):
        self._result = result
    def execute(self):
        return self._result

class _FakeEvents:
    def insert(self, calendarId, body):
        return _Exec({**body, 'id': 'evt_789'})

class _FakeService:
    def events(self):
        return _FakeEvents()

service = _FakeService()
created = create_event_with_reminders(
    service, 'Deploy Review', '2026-08-12T15:00:00', '2026-08-12T15:30:00'
)
print(f'Event id: {created["id"]}')
print('Reminders:', created['reminders']['overrides'])

Toistuvien tapahtumien luominen

Toistuvissa tapahtumissa käytetään RRULE-merkkijonoa eli toistuvuussääntöä, joka noudattaa samaa muotoa kuin iCalendar RFC 5545. Yleisiä sääntöjä ovat esimerkiksi FREQ=WEEKLY;BYDAY=MO,WE,FR maanantaille, keskiviikolle ja perjantaille sekä FREQ=MONTHLY;BYDAY=1MO kunkin kuukauden ensimmäiselle maanantaille.

def create_recurring_event(service, title, start_iso, end_iso,
                           rrule, timezone='UTC'):
    event = {
        'summary': title,
        'start': {'dateTime': start_iso, 'timeZone': timezone},
        'end': {'dateTime': end_iso, 'timeZone': timezone},
        'recurrence': [
            f'RRULE:{rrule}'  # recurrence rule string
        ]
    }

    return service.events().insert(
        calendarId='primary',
        body=event
    ).execute()

# Weekly team standup every Monday at 9am for 30 min
create_recurring_event(
    service=calendar_service,
    title='Team Standup',
    start_iso='2026-06-01T09:00:00',
    end_iso='2026-06-01T09:30:00',
    rrule='FREQ=WEEKLY;BYDAY=MO;COUNT=52',  # 52 weeks
    timezone='America/New_York'
)

Olemassa olevan tapahtuman päivittäminen

Päivittäkää olemassa olevan tapahtuman tiettyjä kenttiä ilman koko tapahtuman korvaamista käyttämällä kohdetta service.events().patch(). Korvatkaa koko tapahtuman runko käyttämällä kohdetta .update(). Molemmat edellyttävät alkuperäisestä create- tai list-vastauksesta saatua tapahtumatunnusta.

def reschedule_event(service, event_id, new_start_iso, new_end_iso,
                     timezone='UTC', calendar_id='primary'):
    updated_fields = {
        'start': {'dateTime': new_start_iso, 'timeZone': timezone},
        'end': {'dateTime': new_end_iso, 'timeZone': timezone}
    }

    updated_event = service.events().patch(
        calendarId=calendar_id,
        eventId=event_id,
        body=updated_fields,
        sendUpdates='all'  # notify attendees of the change
    ).execute()

    print(f'Event rescheduled: {updated_event["summary"]}')
    print(f'New start: {updated_event["start"]["dateTime"]}')
    return updated_event

# --- demo: minimal stand-in for the Calendar API's service object ---
class _Exec:
    def __init__(self, result):
        self._result = result
    def execute(self):
        return self._result

class _FakeEvents:
    def patch(self, calendarId, eventId, body, sendUpdates=None):
        return _Exec({'summary': 'Team Sync', 'id': eventId, **body})

class _FakeService:
    def events(self):
        return _FakeEvents()

service = _FakeService()
reschedule_event(service, 'evt_123', '2026-08-13T09:00:00', '2026-08-13T10:00:00')

Tapahtumien poistaminen

Perukaa ja poistakaa tapahtuma käyttämällä kohdetta service.events().delete(). Asetus sendUpdates='all' ilmoittaa osallistujille. Toistuvista tapahtumista voitte poistaa joko yksittäisen esiintymän tai koko sarjan käytetyn tapahtumatunnuksen mukaan.

from googleapiclient.errors import HttpError

def cancel_event(service, event_id, notify_attendees=True,
                 calendar_id='primary'):
    try:
        service.events().delete(
            calendarId=calendar_id,
            eventId=event_id,
            sendUpdates='all' if notify_attendees else 'none'
        ).execute()
        print(f'Event {event_id} cancelled')
        return True
    except HttpError as e:
        if e.resp.status == 404:
            print(f'Event {event_id} not found (already deleted?)')
        elif e.resp.status == 403:
            print('No permission to delete this event')
        else:
            print(f'Delete failed: {e.resp.status}')
        return False

Vapaan ja varatun ajan tarkistaminen

Tarkistakaa osallistujien saatavuus ennen kokouksen ajoittamista käyttämällä freebusy-APIa. Se palauttaa annetun aikavälin varatut ajanjaksot kalenteriluettelolle, joten se sopii erinomaisesti vapaiden aikojen löytämiseen kokouksia ajoittaville agenteille.

import datetime
import pytz

def check_availability(service, attendees, duration_hours=1):
    now = datetime.datetime.now(pytz.utc)
    time_min = now.isoformat()
    time_max = (now + datetime.timedelta(days=5)).isoformat()

    body = {
        'timeMin': time_min,
        'timeMax': time_max,
        'timeZone': 'UTC',
        'items': [{'id': email} for email in attendees]
    }

    result = service.freebusy().query(body=body).execute()

    for email in attendees:
        busy_slots = result['calendars'].get(email, {}).get('busy', [])
        print(f'{email}: {len(busy_slots)} busy slots in next 5 days')
        for slot in busy_slots[:3]:
            print(f'  Busy: {slot["start"]} -> {slot["end"]}')

    return result

Tapahtumien hakeminen kyselyn perusteella

Hakekaa tapahtumia tekstin perusteella käyttämällä events().list()-kutsun q-parametria. Haku kattaa otsikon, kuvauksen, sijainnin ja osallistujien nimet. Yhdistäkää haku parametreihin timeMin/timeMax, jos haluatte rajata tulokset tiettyyn ajanjaksoon.

def search_events(service, query, days_back=30, days_forward=30,
                  calendar_id='primary'):
    import datetime, pytz
    now = datetime.datetime.now(pytz.utc)

    result = service.events().list(
        calendarId=calendar_id,
        q=query,
        timeMin=(now - datetime.timedelta(days=days_back)).isoformat(),
        timeMax=(now + datetime.timedelta(days=days_forward)).isoformat(),
        singleEvents=True,
        orderBy='startTime',
        maxResults=50
    ).execute()

    events = result.get('items', [])
    print(f'Found {len(events)} events matching "{query}"')
    for event in events:
        start = event['start'].get('dateTime', event['start'].get('date'))
        print(f'  {start}: {event["summary"]}')
    return events

Pikatarkistus: singleEvents-parametri

Testatkaa Calendar API:n tuntemustanne.

Vastaa interaktiivisessa oppitunnissa

Calendar API:n yhteenveto

Agenttinne voivat nyt hallita Google Calendaria ohjelmallisesti:

Tapahtumien luetteleminen: events().list(timeMin=now, singleEvents=True, orderBy='startTime')
Tapahtumien luominen: events().insert(body={summary, start, end, attendees})
Toistuvat tapahtumat: lisätkää recurrence: ['RRULE:FREQ=WEEKLY;BYDAY=MO']
Muistutukset: käyttäkää kohdetta reminders.overrides yhdessä arvojen method: popup/email ja minutes kanssa
Päivittäminen: käyttäkää osittaisiin päivityksiin kohdetta events().patch() ja osallistujille ilmoittamiseen asetusta sendUpdates='all'
Vapaa/varattu: tarkistakaa saatavuus ennen ajoittamista kohteella freebusy().query()

Aloita maksutta

Opi Tekoälyagentit tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 60
Oppitunnit: 239

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Kalenteritapahtumien luominen ja hakeminen” ilmainen?

Kyllä – oppitunnin ”Kalenteritapahtumien luominen ja hakeminen” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Tekoälyagentit-kurssin, päivitä CoddyKit PROhon. Tekoälyagentit-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Kalenteritapahtumien luominen ja hakeminen”?

Google Calendar API: tapahtumien luettelointi, kokousten luominen ja muistutusten asettaminen Harjoittelet Tekoälyagentit-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Tekoälyagentit-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Tekoälyagentit-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Kalenteritapahtumien luominen ja hakeminen”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Tekoälyagentit-oppitunnilla?

Kyllä. Jokainen Tekoälyagentit-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Gmailiin yhdistäminen API:n kautta
Sähköpostien ohjelmallinen lukeminen ja lähettäminen
Kalenteritapahtumien luominen ja hakeminen
Yksinkertaisen sähköpostiassistenttiagentin rakentaminen

← Takaisin: Tekoälyagentit