1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
package api
import (
"context"
"fmt"
"log"
"sort"
"strings"
"time"
"task-dashboard/internal/models"
"google.golang.org/api/calendar/v3"
"google.golang.org/api/option"
)
type GoogleCalendarClient struct {
srv *calendar.Service
calendarIDs []string
}
// parseEventTime extracts start/end times from a Google Calendar event, converting to local timezone
func parseEventTime(item *calendar.Event) (start, end time.Time) {
if item.Start.DateTime == "" {
// All-day event - parse in local timezone
start, _ = time.ParseInLocation("2006-01-02", item.Start.Date, time.Local)
end, _ = time.ParseInLocation("2006-01-02", item.End.Date, time.Local)
} else {
// Timed event - parse RFC3339 then convert to local
start, _ = time.Parse(time.RFC3339, item.Start.DateTime)
end, _ = time.Parse(time.RFC3339, item.End.DateTime)
start = start.Local()
end = end.Local()
}
return
}
// deduplicateEvents removes duplicate events (same summary + start time)
func deduplicateEvents(events []models.CalendarEvent) []models.CalendarEvent {
seen := make(map[string]bool)
var unique []models.CalendarEvent
for _, event := range events {
key := fmt.Sprintf("%s|%d", event.Summary, event.Start.Unix())
if !seen[key] {
seen[key] = true
unique = append(unique, event)
}
}
sort.Slice(unique, func(i, j int) bool {
return unique[i].Start.Before(unique[j].Start)
})
return unique
}
// NewGoogleCalendarClient creates a client that fetches from multiple calendars.
// calendarIDs can be comma-separated (e.g., "cal1@group.calendar.google.com,cal2@group.calendar.google.com")
func NewGoogleCalendarClient(ctx context.Context, credentialsFile, calendarIDs string) (*GoogleCalendarClient, error) {
// Use type-safe credential loading (replaces deprecated WithCredentialsFile)
srv, err := calendar.NewService(ctx, option.WithAuthCredentialsFile(option.ServiceAccount, credentialsFile))
if err != nil {
return nil, fmt.Errorf("unable to retrieve Calendar client: %v", err)
}
// Parse comma-separated calendar IDs
ids := strings.Split(calendarIDs, ",")
var trimmedIDs []string
for _, id := range ids {
if trimmed := strings.TrimSpace(id); trimmed != "" {
trimmedIDs = append(trimmedIDs, trimmed)
}
}
return &GoogleCalendarClient{
srv: srv,
calendarIDs: trimmedIDs,
}, nil
}
func (c *GoogleCalendarClient) GetUpcomingEvents(ctx context.Context, maxResults int) ([]models.CalendarEvent, error) {
t := time.Now().Format(time.RFC3339)
var allEvents []models.CalendarEvent
for _, calendarID := range c.calendarIDs {
events, err := c.srv.Events.List(calendarID).ShowDeleted(false).
SingleEvents(true).TimeMin(t).MaxResults(int64(maxResults)).OrderBy("startTime").Do()
if err != nil {
log.Printf("Warning: failed to fetch events from calendar %s: %v", calendarID, err)
continue
}
for _, item := range events.Items {
start, end := parseEventTime(item)
allEvents = append(allEvents, models.CalendarEvent{
ID: item.Id,
Summary: item.Summary,
Description: item.Description,
Start: start,
End: end,
HTMLLink: item.HtmlLink,
})
}
}
uniqueEvents := deduplicateEvents(allEvents)
if len(uniqueEvents) > maxResults {
uniqueEvents = uniqueEvents[:maxResults]
}
return uniqueEvents, nil
}
func (c *GoogleCalendarClient) GetEventsByDateRange(ctx context.Context, start, end time.Time) ([]models.CalendarEvent, error) {
timeMin := start.Format(time.RFC3339)
timeMax := end.Format(time.RFC3339)
var allEvents []models.CalendarEvent
for _, calendarID := range c.calendarIDs {
events, err := c.srv.Events.List(calendarID).ShowDeleted(false).
SingleEvents(true).TimeMin(timeMin).TimeMax(timeMax).OrderBy("startTime").Do()
if err != nil {
log.Printf("Warning: failed to fetch events from calendar %s: %v", calendarID, err)
continue
}
for _, item := range events.Items {
evtStart, evtEnd := parseEventTime(item)
allEvents = append(allEvents, models.CalendarEvent{
ID: item.Id,
Summary: item.Summary,
Description: item.Description,
Start: evtStart,
End: evtEnd,
HTMLLink: item.HtmlLink,
})
}
}
return deduplicateEvents(allEvents), nil
}
|
