cmd/mi: optionally syndicate events to flyghttracker

Depends on superfly/flyght-tracker#2

6 files changed, 226 insertions, 5 deletions

diff --git a/cmd/mi/main.go b/cmd/mi/main.go
index 173b0c0..5147ae3 100644
--- a/cmd/mi/main.go
+++ b/cmd/mi/main.go
@@ -26,6 +26,9 @@ var (
 	dbLoc        = flag.String("db-loc", "./var/data.db", "")
 	internalBind = flag.String("internal-bind", ":9195", "HTTP internal routes bind address")
 
+	// Events flags
+	flyghtTrackerURL = flag.String("flyght-tracker-url", "", "Flyght Tracker URL")
+
 	// POSSE flags
 	blueskyAuthkey   = flag.String("bsky-authkey", "", "Bluesky authkey")
 	blueskyHandle    = flag.String("bsky-handle", "", "Bluesky handle")
@@ -51,6 +54,7 @@ func main() {
 		"mastodon-url", *mastodonURL,
 		"mastodon-username", *mastodonUsername,
 		"have-mimi-announce-url", *mimiAnnounceURL != "",
+		"have-flyght-tracker-url", *flyghtTrackerURL != "",
 	)
 
 	dao, err := models.New(*dbLoc)
@@ -76,7 +80,7 @@ func main() {
 
 	mux.Handle(announce.AnnouncePathPrefix, announce.NewAnnounceServer(ann))
 	mux.Handle(pb.SwitchTrackerPathPrefix, pb.NewSwitchTrackerServer(switchtracker.New(dao)))
-	mux.Handle(pb.EventsPathPrefix, pb.NewEventsServer(events.New(dao)))
+	mux.Handle(pb.EventsPathPrefix, pb.NewEventsServer(events.New(dao, *flyghtTrackerURL)))
 	mux.Handle("/front", homefrontshim.New(dao))
 
 	i := importer.New(dao)
diff --git a/cmd/mi/models/events.go b/cmd/mi/models/events.go
index c4239b2..0e60fb9 100644
--- a/cmd/mi/models/events.go
+++ b/cmd/mi/models/events.go
@@ -19,6 +19,7 @@ type Event struct {
 	EndDate     time.Time
 	Location    string `gorm:"index"`
 	Description string
+	Syndicate   bool
 }
 
 func (e *Event) AsProto() *pb.Event {
@@ -30,6 +31,7 @@ func (e *Event) AsProto() *pb.Event {
 		EndDate:     timestamppb.New(e.EndDate),
 		Location:    e.Location,
 		Description: e.Description,
+		Syndicate:   e.Syndicate,
 	}
 }
 
diff --git a/cmd/mi/services/events/events.go b/cmd/mi/services/events/events.go
index bbc1015..6921306 100644
--- a/cmd/mi/services/events/events.go
+++ b/cmd/mi/services/events/events.go
@@ -5,22 +5,35 @@ import (
 	"errors"
 	"log/slog"
 
+	_ "github.com/lib/pq"
 	"github.com/twitchtv/twirp"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"gorm.io/gorm"
 	"within.website/x/cmd/mi/models"
+	"within.website/x/cmd/mi/services/events/flyghttracker"
 	pb "within.website/x/proto/mi"
 )
 
 type Events struct {
-	dao *models.DAO
+	dao           *models.DAO
+	flyghtTracker *flyghttracker.Client
 }
 
 var _ pb.Events = &Events{}
 
 // New creates a new Events service.
-func New(dao *models.DAO) *Events {
-	return &Events{dao: dao}
+func New(dao *models.DAO, flyghtTrackerURL string) *Events {
+	result := &Events{
+		dao: dao,
+	}
+
+	if flyghtTrackerURL != "" {
+		result.flyghtTracker = flyghttracker.New(flyghtTrackerURL)
+	} else {
+		slog.Warn("no flyght tracker database URL provided, not syndicating events to flyght tracker")
+	}
+
+	return result
 }
 
 // Get fetches upcoming events.
@@ -57,6 +70,7 @@ func (e *Events) Add(ctx context.Context, ev *pb.Event) (*emptypb.Empty, error)
 		EndDate:     ev.EndDate.AsTime(),
 		Location:    ev.Location,
 		Description: ev.Description,
+		Syndicate:   ev.Syndicate,
 	}
 
 	_, err := e.dao.CreateEvent(ctx, event)
@@ -66,5 +80,11 @@ func (e *Events) Add(ctx context.Context, ev *pb.Event) (*emptypb.Empty, error)
 
 	slog.Info("tracking new event", "event", event)
 
+	if e.flyghtTracker != nil {
+		if err := e.syndicateToFlyghtTracker(ctx, ev); err != nil {
+			slog.Error("can't syndicate event to flyght tracker", "err", err)
+		}
+	}
+
 	return &emptypb.Empty{}, nil
 }
diff --git a/cmd/mi/services/events/flyghttracker.go b/cmd/mi/services/events/flyghttracker.go
new file mode 100644
index 0000000..fce3f70
--- /dev/null
+++ b/cmd/mi/services/events/flyghttracker.go
@@ -0,0 +1,38 @@
+package events
+
+import (
+	"context"
+	"log/slog"
+
+	"within.website/x/cmd/mi/services/events/flyghttracker"
+	pb "within.website/x/proto/mi"
+)
+
+func (e *Events) syndicateToFlyghtTracker(ctx context.Context, ev *pb.Event) error {
+	if !ev.GetSyndicate() {
+		slog.Debug("not syndicating event to flyght tracker", "event", ev)
+		return nil
+	}
+
+	ftev := flyghttracker.Event{
+		Name: ev.GetName(),
+		URL:  ev.GetUrl(),
+		StartDate: flyghttracker.Date{
+			Time: ev.GetStartDate().AsTime(),
+		},
+		Location: ev.GetLocation(),
+		People:   []string{"Xe"},
+	}
+
+	if ev.GetStartDate().Seconds != ev.GetEndDate().Seconds {
+		ftev.EndDate = flyghttracker.Date{
+			Time: ev.GetEndDate().AsTime(),
+		}
+	}
+
+	if err := e.flyghtTracker.Create(ctx, ftev); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/cmd/mi/services/events/flyghttracker/flyghttracker.go b/cmd/mi/services/events/flyghttracker/flyghttracker.go
new file mode 100644
index 0000000..f6398fb
--- /dev/null
+++ b/cmd/mi/services/events/flyghttracker/flyghttracker.go
@@ -0,0 +1,154 @@
+package flyghttracker
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"strings"
+	"time"
+
+	"within.website/x/web"
+)
+
+var (
+	flyghttrackerURL = flag.String("flyghttracker-url", "https://flyght-tracker.fly.dev/api/upcoming_events", "Flyghttracker URL")
+)
+
+// Date represents a date in the format "YYYY-MM-DD"
+type Date struct {
+	time.Time
+}
+
+// UnmarshalJSON parses a JSON string in the format "YYYY-MM-DD" to a Date
+func (d *Date) UnmarshalJSON(b []byte) error {
+	s := strings.Trim(string(b), "\"")
+	t, err := time.Parse("2006-01-02", s)
+	if err != nil {
+		return err
+	}
+	d.Time = t
+	return nil
+}
+
+// MarshalJSON returns a JSON string in the format "YYYY-MM-DD"
+func (d Date) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.Time.Format("2006-01-02"))
+}
+
+// Event represents an event that members of DevRel will be attending.
+type Event struct {
+	ID        string   `json:"id,omitempty"`
+	Name      string   `json:"name,omitempty"`
+	URL       string   `json:"url,omitempty"`
+	StartDate Date     `json:"start_date,omitempty"`
+	EndDate   Date     `json:"end_date,omitempty"`
+	Location  string   `json:"location,omitempty"`
+	People    []string `json:"people,omitempty"`
+}
+
+type Error struct {
+	Code   int
+	Detail string `json:"detail"`
+}
+
+func (e Error) LogValues() slog.Value {
+	return slog.GroupValue(
+		slog.Int("code", e.Code),
+		slog.String("detail", e.Detail),
+	)
+}
+
+func (e Error) Error() string {
+	return fmt.Sprintf("flyghttracker: %d %s", e.Code, e.Detail)
+}
+
+type Client struct {
+	URL string
+}
+
+// New creates a new Flyght Tracker client.
+func New(url string) *Client {
+	return &Client{
+		URL: url,
+	}
+}
+
+// Create creates a new Flyght Tracker event.
+func (c *Client) Create(ctx context.Context, event Event) error {
+	body, err := json.Marshal(event)
+	if err != nil {
+		return fmt.Errorf("failed to marshal event: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.URL+"/api/events", bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to create event: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		var e Error
+		if err := json.NewDecoder(resp.Body).Decode(&e); err != nil {
+			return fmt.Errorf("failed to decode error: %w", err)
+		}
+
+		e.Code = resp.StatusCode
+
+		return e
+	}
+
+	return nil
+}
+
+// Fetch new events from the Flyght Tracker URL.
+//
+// It returns a list of events that end in the future and that have "Xe" as one of the attendees.
+func (c *Client) Fetch() ([]Event, error) {
+	resp, err := http.Get(c.URL + "/api/upcoming_events")
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch flyghttracker events: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, web.NewError(http.StatusOK, resp)
+	}
+
+	var events []Event
+	if err := json.NewDecoder(resp.Body).Decode(&events); err != nil {
+		return nil, fmt.Errorf("failed to decode flyghttracker events: %w", err)
+	}
+
+	var result []Event
+
+	for _, event := range events {
+		if event.EndDate.Before(time.Now()) {
+			continue
+		}
+
+		found := false
+		for _, person := range event.People {
+			if person == "Xe" {
+				found = true
+				break
+			}
+		}
+
+		if found {
+			result = append(result, event)
+		}
+	}
+
+	return result, nil
+}
diff --git a/cmd/x/mi.go b/cmd/x/mi.go
index ba183ff..71bd57f 100644
--- a/cmd/x/mi.go
+++ b/cmd/x/mi.go
@@ -188,12 +188,13 @@ type miAddEvent struct {
 	endDate     string
 	location    string
 	description string
+	syndicate   bool
 }
 
 func (*miAddEvent) Name() string     { return "add-event" }
 func (*miAddEvent) Synopsis() string { return "Add an event to be attended." }
 func (*miAddEvent) Usage() string {
-	return `add-event [--name] [--url] [--start-date] [--end-date] [--location] [--description]:
+	return `add-event [--name] [--url] [--start-date] [--end-date] [--location] [--description] [--syndicate]:
 Add an event to be attended.
 `
 }
@@ -204,6 +205,7 @@ func (ae *miAddEvent) SetFlags(f *flag.FlagSet) {
 	f.StringVar(&ae.endDate, "end-date", "", "End date of the event.")
 	f.StringVar(&ae.location, "location", "", "Location of the event.")
 	f.StringVar(&ae.description, "description", "", "Description of the event.")
+	f.BoolVar(&ae.syndicate, "syndicate", false, "Syndicate this event to other services.")
 }
 
 func (ae *miAddEvent) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
@@ -292,6 +294,7 @@ func (ae *miAddEvent) Execute(ctx context.Context, f *flag.FlagSet, _ ...interfa
 		EndDate:     timestamppb.New(endDate),
 		Location:    ae.location,
 		Description: ae.description,
+		Syndicate:   ae.syndicate,
 	}
 
 	slog.Info("adding event", "event", ev)