[GCAL] Channels reminder underlying logic

server/mscalendar/availability.go

@@ -505,7 +505,7 @@ func (m *mscalendar) notifyUpcomingEvents(mattermostUserID string, events []*rem
 				}
 			}
 
-			_, attachment, err := views.RenderUpcomingEventAsAttachment(event, timezone)
+			message, attachment, err := views.RenderUpcomingEventAsAttachment(event, timezone)
 			if err != nil {
 				m.Logger.Warnf("notifyUpcomingEvent error rendering schedule item. err=%v", err)
 				continue
@@ -516,6 +516,31 @@ func (m *mscalendar) notifyUpcomingEvents(mattermostUserID string, events []*rem
 				m.Logger.Warnf("notifyUpcomingEvents error creating DM. err=%v", err)
 				continue
 			}
+
+			// Process channel reminders
+			eventMetadata, errMetadata := m.Store.LoadEventMetadata(event.GetMainID())
+			if errMetadata != nil && !errors.Is(errMetadata, store.ErrNotFound) {
+				m.Logger.With(bot.LogContext{
+					"eventID": event.ID,
+					"err":     errMetadata.Error(),
+				}).Warnf("notifyUpcomingEvents error checking store for channel notifications")
+				continue
+			}
+
+			if eventMetadata != nil {
+				for channelID := range eventMetadata.LinkedChannels {
+					post := &model.Post{
+						ChannelId: channelID,
+						Message:   message,
+					}
+					model.ParseSlackAttachment(post, []*model.SlackAttachment{attachment})
+					err = m.Poster.CreatePost(post)
+					if err != nil {
+						m.Logger.Warnf("notifyUpcomingEvents error creating post in channel. err=%v", err)
+						continue
+					}
+				}
+			}
 		}
 	}
 }

server/mscalendar/availability_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/mattermost/mattermost-plugin-mscalendar/server/store"
 	"github.com/mattermost/mattermost-plugin-mscalendar/server/store/mock_store"
 	"github.com/mattermost/mattermost-plugin-mscalendar/server/utils/bot/mock_bot"
+	"github.com/mattermost/mattermost-plugin-mscalendar/server/utils/test"
 )
 
 func TestSyncStatusAll(t *testing.T) {
@@ -249,6 +250,7 @@ func TestReminders(t *testing.T) {
 	for name, tc := range map[string]struct {
 		apiError       *remote.APIError
 		remoteEvents   []*remote.Event
+		eventMetadata  map[string]*store.EventMetadata
 		numReminders   int
 		shouldLogError bool
 	}{
@@ -293,6 +295,30 @@ func TestReminders(t *testing.T) {
 			numReminders:   2,
 			shouldLogError: false,
 		},
+		"Remote event linked to channel in the range for the reminder. DM and channel reminders should occur.": {
+			remoteEvents: []*remote.Event{
+				{ID: "event_id", ICalUID: "event_id", Start: remote.NewDateTime(time.Now().Add(7*time.Minute).UTC(), "UTC"), End: remote.NewDateTime(time.Now().Add(45*time.Minute).UTC(), "UTC")},
+			},
+			eventMetadata: map[string]*store.EventMetadata{
+				"event_id": {
+					LinkedChannels: map[string]struct{}{"channel_id": {}},
+				},
+			},
+			numReminders:   1,
+			shouldLogError: false,
+		},
+		"Remote recurring event linked to channel in the range for the reminder. DM and channel reminders should occur.": {
+			remoteEvents: []*remote.Event{
+				{ID: "event_id_20230728", RecurringEventID: "event_id", ICalUID: "event_id", Start: remote.NewDateTime(time.Now().Add(7*time.Minute).UTC(), "UTC"), End: remote.NewDateTime(time.Now().Add(45*time.Minute).UTC(), "UTC")},
+			},
+			eventMetadata: map[string]*store.EventMetadata{
+				"event_id": {
+					LinkedChannels: map[string]struct{}{"channel_id": {}},
+				},
+			},
+			numReminders:   1,
+			shouldLogError: false,
+		},
 		"Remote API Error. Error should be logged.": {
 			remoteEvents:   []*remote.Event{},
 			numReminders:   0,
@@ -333,6 +359,17 @@ func TestReminders(t *testing.T) {
 				poster.EXPECT().DMWithAttachments("user_mm_id", gomock.Any()).Times(tc.numReminders)
 				loadUser.Times(2)
 				c.EXPECT().GetMailboxSettings("user_remote_id").Times(1).Return(&remote.MailboxSettings{TimeZone: "UTC"}, nil)
+
+				// Metadata (linked channels test)
+				for eventID, metadata := range tc.eventMetadata {
+					s.EXPECT().LoadEventMetadata(eventID).Return(metadata, nil).Times(1)
+					for channelID := range metadata.LinkedChannels {
+						poster.EXPECT().CreatePost(test.DoMatch(func(v *model.Post) bool {
+							return v.ChannelId == channelID
+						})).Return(nil)
+					}
+				}
+				s.EXPECT().LoadEventMetadata(gomock.Any()).Return(nil, store.ErrNotFound).Times(tc.numReminders - len(tc.eventMetadata))
 			} else {
 				poster.EXPECT().DM(gomock.Any(), gomock.Any()).Times(0)
 				loadUser.Times(1)

server/mscalendar/daily_summary_test.go

@@ -257,6 +257,113 @@ Wednesday February 12, 2020
 					mockPoster.EXPECT().DM("user2_mm_id", `Times are shown in Pacific Standard Time
 Wednesday February 12, 2020
 
+| Time | Subject |
+| :--: | :-- |
+| 9:00AM - 11:00AM | [The subject]() |`).Return("postID2", nil).Times(1),
+				)
+
+				s.EXPECT().StoreUser(gomock.Any()).Times(2).DoAndReturn(func(u *store.User) error {
+					require.NotEmpty(t, u.Settings.DailySummary.LastPostTime)
+					return nil
+				})
+
+				mockLogger := deps.Logger.(*mock_bot.MockLogger)
+				mockLogger.EXPECT().Infof("Processed daily summary for %d users", 2)
+			},
+		},
+		{
+			name: "User receives their daily summary (individual data call)",
+			err:  "",
+			runAssertions: func(deps *Dependencies, client remote.Client) {
+				s := deps.Store.(*mock_store.MockStore)
+				mockRemote := deps.Remote.(*mock_remote.MockRemote)
+				mockClient := client.(*mock_remote.MockClient)
+				papi := deps.PluginAPI.(*mock_plugin_api.MockPluginAPI)
+
+				loc, err := time.LoadLocation("MST")
+				require.Nil(t, err)
+				hour, minute := 10, 0 // Time is "10:00AM"
+				moment := makeTime(hour, minute, loc)
+
+				s.EXPECT().LoadUserIndex().Return(store.UserIndex{{
+					MattermostUserID: "user1_mm_id",
+					RemoteID:         "user1_remote_id",
+				}, {
+					MattermostUserID: "user2_mm_id",
+					RemoteID:         "user2_remote_id",
+				}, {
+					MattermostUserID: "user3_mm_id",
+					RemoteID:         "user3_remote_id",
+				}}, nil)
+
+				mockRemote.EXPECT().MakeSuperuserClient(context.Background()).Return(nil, remote.ErrSuperUserClientNotSupported).Times(1)
+
+				s.EXPECT().LoadUser("user1_mm_id").Return(&store.User{
+					MattermostUserID: "user1_mm_id",
+					Remote:           &remote.User{ID: "user1_remote_id"},
+					Settings: store.Settings{
+						DailySummary: &store.DailySummaryUserSettings{
+							Enable:       true,
+							PostTime:     "9:00AM",
+							Timezone:     "Eastern Standard Time",
+							LastPostTime: "",
+						},
+					},
+				}, nil).Times(3)
+
+				s.EXPECT().LoadUser("user2_mm_id").Return(&store.User{
+					MattermostUserID: "user2_mm_id",
+					Remote:           &remote.User{ID: "user2_remote_id"},
+					Settings: store.Settings{
+						DailySummary: &store.DailySummaryUserSettings{
+							Enable:       true,
+							PostTime:     "6:00AM",
+							Timezone:     "Pacific Standard Time",
+							LastPostTime: "",
+						},
+					},
+				}, nil).Times(2)
+
+				s.EXPECT().LoadUser("user3_mm_id").Return(&store.User{
+					MattermostUserID: "user3_mm_id",
+					Remote:           &remote.User{ID: "user3_remote_id"},
+					Settings: store.Settings{
+						DailySummary: &store.DailySummaryUserSettings{
+							Enable:       true,
+							PostTime:     "10:00AM", // should not receive summary
+							Timezone:     "Pacific Standard Time",
+							LastPostTime: "",
+						},
+					},
+				}, nil)
+
+				papi.EXPECT().GetMattermostUser("user1_mm_id").Times(2)
+				papi.EXPECT().GetMattermostUser("user2_mm_id").Times(1)
+
+				mockClient.EXPECT().GetMailboxSettings("user1_remote_id").Return(&remote.MailboxSettings{
+					TimeZone: "Eastern Standard Time",
+				}, nil)
+				mockClient.EXPECT().GetMailboxSettings("user2_remote_id").Return(&remote.MailboxSettings{
+					TimeZone: "Pacific Standard Time",
+				}, nil)
+
+				mockRemote.EXPECT().MakeClient(context.TODO(), gomock.Any()).Return(mockClient)
+
+				mockClient.EXPECT().GetDefaultCalendarView("user1_remote_id", gomock.Any(), gomock.Any()).Return([]*remote.Event{}, nil)
+				mockClient.EXPECT().GetDefaultCalendarView("user2_remote_id", gomock.Any(), gomock.Any()).Return([]*remote.Event{
+					{
+						Subject: "The subject",
+						Start:   remote.NewDateTime(moment, "Mountain Standard Time"),
+						End:     remote.NewDateTime(moment.Add(2*time.Hour), "Mountain Standard Time"),
+					},
+				}, nil)
+
+				mockPoster := deps.Poster.(*mock_bot.MockPoster)
+				gomock.InOrder(
+					mockPoster.EXPECT().DM("user1_mm_id", "You have no upcoming events.").Return("postID1", nil).Times(1),
+					mockPoster.EXPECT().DM("user2_mm_id", `Times are shown in Pacific Standard Time
+Wednesday February 12, 2020
+
 | Time | Subject |
 | :--: | :-- |
 | 9:00AM - 11:00AM | [The subject]() |`).Return("postID2", nil).Times(1),

server/mscalendar/views/calendar.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"net/url"
 	"sort"
-	"strings"
 	"time"
 
 	"github.com/mattermost/mattermost-server/v6/model"
@@ -113,12 +112,14 @@ func renderEvent(event *remote.Event, asRow bool, timeZone string) (string, erro
 }
 
 func isKnownMeetingURL(location string) bool {
-	return strings.Contains(location, "zoom.us/j/") || strings.Contains(location, "discord.gg") || strings.Contains(location, "meet.google.com")
+	_, err := url.ParseRequestURI(location)
+	return err == nil
 }
 
 func renderEventAsAttachment(event *remote.Event, timezone string) (*model.SlackAttachment, error) {
 	var actions []*model.PostAction
 	fields := []*model.SlackAttachmentField{}
+	var titleLink string
 
 	if event.Location != nil && event.Location.DisplayName != "" {
 		fields = append(fields, &model.SlackAttachmentField{
@@ -127,19 +128,18 @@ func renderEventAsAttachment(event *remote.Event, timezone string) (*model.Slack
 			Short: true,
 		})
 
-		// Add actions for known links
-		// Disable join meeting button for now, since we don't have a handler and
-		// the location url is shown parsed and clickable anyway.
-		// if joinMeetingAction := getActionForLocation(event.Location); joinMeetingAction != nil {
-		// 	actions = append(actions, joinMeetingAction)
-		// }
+		// Use location display name as link if can be parsed as an URL
+		if isKnownMeetingURL(event.Location.DisplayName) {
+			titleLink = event.Location.DisplayName
+		}
 	}
 
 	return &model.SlackAttachment{
-		Title:   event.Subject,
-		Text:    fmt.Sprintf("(%s - %s)", event.Start.In(timezone).Time().Format(time.Kitchen), event.End.In(timezone).Time().Format(time.Kitchen)),
-		Fields:  fields,
-		Actions: actions,
+		Title:     event.Subject,
+		TitleLink: titleLink,
+		Text:      fmt.Sprintf("(%s - %s)", event.Start.In(timezone).Time().Format(time.Kitchen), event.End.In(timezone).Time().Format(time.Kitchen)),
+		Fields:    fields,
+		Actions:   actions,
 	}, nil
 }
 
@@ -189,7 +189,7 @@ func EnsureSubject(s string) string {
 }
 
 func RenderUpcomingEventAsAttachment(event *remote.Event, timeZone string) (message string, attachment *model.SlackAttachment, err error) {
-	message = "You have an upcoming event:\n"
+	message = "Upcoming event:\n"
 	attachment, err = renderEventAsAttachment(event, timeZone)
 	return message, attachment, err
 }

server/remote/event.go

@@ -18,6 +18,7 @@ type Event struct {
 	ShowAs                     string               `json:"showAs,omitempty"`
 	Weblink                    string               `json:"weblink,omitempty"`
 	ID                         string               `json:"id,omitempty"`
+	RecurringEventID           string               `json:"recurringEventId,omitempty"`
 	Attendees                  []*Attendee          `json:"attendees,omitempty"`
 	ReminderMinutesBeforeStart int                  `json:"reminderMinutesBeforeStart,omitempty"`
 	IsOrganizer                bool                 `json:"isOrganizer,omitempty"`
@@ -26,6 +27,13 @@ type Event struct {
 	ResponseRequested          bool                 `json:"responseRequested,omitempty"`
 }
 
+func (e Event) GetMainID() string {
+	if e.RecurringEventID != "" {
+		return e.RecurringEventID
+	}
+	return e.ID
+}
+
 type ItemBody struct {
 	Content     string `json:"content,omitempty"`
 	ContentType string `json:"contentType,omitempty"`

server/remote/gcal/get_default_calendar_view.go

@@ -141,6 +141,7 @@ func convertGCalEventToRemoteEvent(event *calendar.Event) *remote.Event {
 
 	return &remote.Event{
 		ID:                event.Id,
+		RecurringEventID:  event.RecurringEventId,
 		ICalUID:           event.ICalUID,
 		Subject:           event.Summary,
 		Body:              &remote.ItemBody{Content: event.Description},

server/store/event_store.go

@@ -7,6 +7,8 @@ import (
 	"encoding/json"
 	"time"
 
+	"github.com/pkg/errors"
+
 	"github.com/mattermost/mattermost-plugin-mscalendar/server/remote"
 	"github.com/mattermost/mattermost-plugin-mscalendar/server/utils/bot"
 	"github.com/mattermost/mattermost-plugin-mscalendar/server/utils/kvstore"
@@ -18,18 +20,29 @@ import (
 const ttlAfterEventEnd = 30 * 24 * time.Hour // 30 days
 const defaultEventTTL = 30 * 24 * time.Hour  // 30 days
 
+type EventMetadata struct {
+	LinkedChannels map[string]struct{}
+}
+
 type Event struct {
 	Remote        *remote.Event
 	PluginVersion string
 }
 
 type EventStore interface {
+	LoadEventMetadata(eventID string) (*EventMetadata, error)
+	StoreEventMetadata(eventID string, eventMeta *EventMetadata) error
+
+	AddLinkedChannelToEvent(eventID, channelID string) error
+	DeleteLinkedChannelFromEvent(eventID, channelID string) error
+
 	LoadUserEvent(mattermostUserID, eventID string) (*Event, error)
 	StoreUserEvent(mattermostUserID string, event *Event) error
 	DeleteUserEvent(mattermostUserID, eventID string) error
 }
 
 func eventKey(mattermostUserID, eventID string) string { return mattermostUserID + "_" + eventID }
+func eventMetaKey(eventID string) string               { return "metadata_" + eventID }
 
 func (s *pluginStore) LoadUserEvent(mattermostUserID, eventID string) (*Event, error) {
 	event := Event{}
@@ -40,6 +53,45 @@ func (s *pluginStore) LoadUserEvent(mattermostUserID, eventID string) (*Event, e
 	return &event, nil
 }
 
+func (s *pluginStore) AddLinkedChannelToEvent(eventID, channelID string) error {
+	eventMeta, err := s.LoadEventMetadata(eventID)
+	if err != nil && !errors.Is(err, ErrNotFound) {
+		return err
+	}
+
+	eventMeta.LinkedChannels[channelID] = struct{}{}
+
+	return s.StoreEventMetadata(eventID, eventMeta)
+}
+
+func (s *pluginStore) DeleteLinkedChannelFromEvent(eventID, channelID string) error {
+	eventMeta, err := s.LoadEventMetadata(eventID)
+	if err != nil && !errors.Is(err, ErrNotFound) {
+		return err
+	}
+
+	delete(eventMeta.LinkedChannels, channelID)
+
+	return s.StoreEventMetadata(eventID, eventMeta)
+}
+
+func (s *pluginStore) StoreEventMetadata(eventID string, eventMeta *EventMetadata) error {
+	err := kvstore.StoreJSON(s.eventKV, eventMetaKey(eventID), &eventMeta)
+	if err != nil {
+		return errors.Wrap(err, "error storing event metadata")
+	}
+	return nil
+}
+
+func (s *pluginStore) LoadEventMetadata(eventID string) (*EventMetadata, error) {
+	event := EventMetadata{}
+	err := kvstore.LoadJSON(s.eventKV, eventMetaKey(eventID), &event)
+	if err != nil {
+		return nil, err
+	}
+	return &event, nil
+}
+
 func (s *pluginStore) StoreUserEvent(mattermostUserID string, event *Event) error {
 	now := time.Now()
 	end := now.Add(defaultEventTTL)