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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
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 - use the event's timezone if specified
var loc *time.Location
if item.Start.TimeZone != "" {
loc, _ = time.LoadLocation(item.Start.TimeZone)
}
if loc == nil {
loc = time.Local
}
// Try parsing with timezone offset first (RFC3339)
start, _ = time.Parse(time.RFC3339, item.Start.DateTime)
end, _ = time.Parse(time.RFC3339, item.End.DateTime)
// If the parsed time is zero (parse failed) or missing timezone info,
// parse in the event's timezone
if start.IsZero() || item.Start.DateTime[len(item.Start.DateTime)-1] != 'Z' && !strings.Contains(item.Start.DateTime, "+") && !strings.Contains(item.Start.DateTime, "-") {
start, _ = time.ParseInLocation("2006-01-02T15:04:05", item.Start.DateTime, loc)
end, _ = time.ParseInLocation("2006-01-02T15:04:05", item.End.DateTime, loc)
}
// Convert to local timezone for display
start = start.In(time.Local)
end = end.In(time.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) {
srv, err := calendar.NewService(ctx, option.WithCredentialsFile(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
}
|
