feat: automatic event ingest from sessionize/meetup (#103)

* feat: add event sync planning layer

* feat: sync sessionize events into umbraco

* fix: use display logic for current events

* chore: refresh event sync test fixtures

* chore: run event sync every two hours

* chore: set default meetup group id

* feat: import sessionize speaker images

* refactor: fetch upcoming meetup events only

* chore: inline meetup fallback

* refactor: inline meetup event fetch

* fix: skip past events during sync

* refactor: simplify sessionize event planning

* refactor: resolve presenter type key by alias

* refactor: split external api namespaces

* feat: match sessionize presenters to members

* refactor: search member presenters by name

* chore regenerate umbraco models

* fix: match meetup titles with event prefixes

* fix: publish presentation explicitly after event to fix race

* chore: add option for enabling event sync

* fix: issues with tests

Author: glitchedmob

SgfDevs.Tests/EventDisplayServiceTests.cs

@@ -0,0 +1,63 @@
+using System;
+using SgfDevs.Dev;
+using Xunit;
+
+namespace SgfDevs.Tests;
+
+public class EventDisplayServiceTests
+{
+    private readonly EventDisplayService _service = new();
+
+    [Fact]
+    public void IsCurrentOrUpcoming_ReturnsTrueBeforeGracePeriodEnds()
+    {
+        var startsAtLocal = new DateTime(2026, 5, 6, 18, 30, 0);
+
+        var result = _service.IsCurrentOrUpcoming(startsAtLocal, new DateTime(2026, 5, 6, 19, 29, 59));
+
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void IsCurrentOrUpcoming_ReturnsFalseOnceGracePeriodEnds()
+    {
+        var startsAtLocal = new DateTime(2026, 5, 6, 18, 30, 0);
+
+        var result = _service.IsCurrentOrUpcoming(startsAtLocal, new DateTime(2026, 5, 6, 19, 30, 0));
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void GetCurrentOrNextEvent_SkipsExpiredEvents()
+    {
+        var now = new DateTime(2026, 5, 6, 20, 0, 0);
+        var events = new[]
+        {
+            new DateTime(2026, 5, 6, 18, 30, 0),
+            new DateTime(2026, 6, 3, 18, 30, 0)
+        };
+
+        var result = _service.GetCurrentOrNextEvent(events, static item => item, now);
+
+        Assert.Equal(new DateTime(2026, 6, 3, 18, 30, 0), result);
+    }
+
+    [Fact]
+    public void GetCurrentAndUpcomingEvents_ReturnsOnlyVisibleWindow()
+    {
+        var now = new DateTime(2026, 5, 6, 19, 0, 0);
+        var events = new[]
+        {
+            new DateTime(2026, 4, 1, 18, 30, 0),
+            new DateTime(2026, 5, 6, 18, 30, 0),
+            new DateTime(2026, 6, 3, 18, 30, 0)
+        };
+
+        var result = _service.GetCurrentAndUpcomingEvents(events, static item => item, now);
+
+        Assert.Equal(
+            [new DateTime(2026, 5, 6, 18, 30, 0), new DateTime(2026, 6, 3, 18, 30, 0)],
+            result);
+    }
+}

SgfDevs.Tests/EventSyncImportFilterTests.cs

@@ -0,0 +1,43 @@
+using System;
+using SgfDevs.Dev.EventSync;
+using SgfDevs.Dev.EventSync.Sessionize;
+using Xunit;
+
+namespace SgfDevs.Tests;
+
+public class EventSyncImportFilterTests
+{
+    private readonly EventSyncImportFilter _filter = new();
+
+    [Fact]
+    public void GetUpcomingEvents_ExcludesPastEvents()
+    {
+        var nowLocal = new DateTime(2026, 6, 3, 18, 0, 0);
+        var plans = new[]
+        {
+            new ImportedEventPlan("Past Dev Night", new DateTime(2026, 5, 6, 18, 30, 0), []),
+            new ImportedEventPlan("Future Dev Night", new DateTime(2026, 7, 1, 18, 30, 0), [])
+        };
+
+        var result = _filter.GetUpcomingEvents(plans, nowLocal);
+
+        var plan = Assert.Single(result);
+        Assert.Equal("Future Dev Night", plan.Name);
+    }
+
+    [Fact]
+    public void GetUpcomingEvents_KeepsEventsStartingNow()
+    {
+        var nowLocal = new DateTime(2026, 6, 3, 18, 30, 0);
+        var plans = new[]
+        {
+            new ImportedEventPlan("Current Dev Night", nowLocal, []),
+            new ImportedEventPlan("Next Dev Night", new DateTime(2026, 7, 1, 18, 30, 0), [])
+        };
+
+        var result = _filter.GetUpcomingEvents(plans, nowLocal);
+
+        Assert.Equal(2, result.Count);
+        Assert.Equal("Current Dev Night", result[0].Name);
+    }
+}

SgfDevs.Tests/ImportedPresenterBlockBuilderTests.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using SgfDevs.Dev.EventSync;
+using SgfDevs.Dev.EventSync.Sessionize;
+using Xunit;
+
+namespace SgfDevs.Tests;
+
+public class ImportedPresenterBlockBuilderTests
+{
+    private readonly ImportedPresenterBlockBuilder _builder = new(
+        new Guid("1bdea08d-8393-4e70-85a9-2ca27bef54f1"),
+        new Guid("5ff3a2c3-9dc3-4131-8f07-99c2c0a38be5"));
+
+    [Fact]
+    public void Build_ReturnsEmptyStringWhenNoPresentersExist()
+    {
+        var result = _builder.Build([]);
+
+        Assert.Equal(string.Empty, result);
+    }
+
+    [Fact]
+    public void Build_CreatesBlockListPayloadForNonMemberPresenters()
+    {
+        var result = _builder.Build(
+        [
+            new ImportedPresenterPlan("speaker-1", "Bertram Gilfoyle", null, MatchedMemberKey: new Guid("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")),
+            new ImportedPresenterPlan("speaker-2", "Dinesh Chugtai", null)
+        ]);
+
+        using var document = JsonDocument.Parse(result);
+        var root = document.RootElement;
+
+        Assert.Equal(2, root.GetProperty("contentData").GetArrayLength());
+        Assert.Equal(2, root.GetProperty("expose").GetArrayLength());
+        Assert.Equal(2, root.GetProperty("Layout").GetProperty("Umbraco.BlockList").GetArrayLength());
+
+        var firstValues = root.GetProperty("contentData")[0].GetProperty("values");
+        Assert.Equal("member", firstValues[0].GetProperty("alias").GetString());
+        Assert.Equal("umb://member/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", firstValues[0].GetProperty("value").GetString());
+
+        var secondValues = root.GetProperty("contentData")[1].GetProperty("values");
+        Assert.Equal("presenterName", secondValues[0].GetProperty("alias").GetString());
+        Assert.Equal("Dinesh Chugtai", secondValues[0].GetProperty("value").GetString());
+        Assert.Equal(string.Empty, secondValues[1].GetProperty("value").GetString());
+    }
+}

SgfDevs.Tests/PresenterMemberMatcherTests.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using SgfDevs.Dev.EventSync;
+using SgfDevs.Dev.EventSync.Sessionize;
+using Xunit;
+
+namespace SgfDevs.Tests;
+
+public class PresenterMemberMatcherTests
+{
+    [Fact]
+    public void MatchPresenters_AssignsMemberKeyWhenExactlyOneMemberMatches()
+    {
+        var memberKey = Guid.NewGuid();
+        var matcher = CreateMatcher(new Dictionary<string, IReadOnlyList<Guid>>
+        {
+            ["bertram gilfoyle"] = [memberKey]
+        });
+
+        var result = Assert.Single(matcher.MatchPresenters([new ImportedPresenterPlan("speaker-1", "Bertram   Gilfoyle", null)]));
+
+        Assert.Equal(memberKey, result.MatchedMemberKey);
+    }
+
+    [Fact]
+    public void MatchPresenters_LeavesPresenterUnchangedWhenNoMembersMatch()
+    {
+        var matcher = CreateMatcher(new Dictionary<string, IReadOnlyList<Guid>>());
+
+        var result = Assert.Single(matcher.MatchPresenters([new ImportedPresenterPlan("speaker-1", "Bertram Gilfoyle", null)]));
+
+        Assert.Null(result.MatchedMemberKey);
+    }
+
+    [Fact]
+    public void MatchPresenters_LeavesPresenterUnchangedWhenMultipleMembersMatch()
+    {
+        var matcher = CreateMatcher(new Dictionary<string, IReadOnlyList<Guid>>
+        {
+            ["bertram gilfoyle"] = [Guid.NewGuid(), Guid.NewGuid()]
+        });
+
+        var result = Assert.Single(matcher.MatchPresenters([new ImportedPresenterPlan("speaker-1", "Bertram Gilfoyle", null)]));
+
+        Assert.Null(result.MatchedMemberKey);
+    }
+
+    [Fact]
+    public void MatchPresenters_DeduplicatesSameMemberReturnedByMultipleSearchTerms()
+    {
+        var memberKey = Guid.NewGuid();
+        var matcher = CreateMatcher(new Dictionary<string, IReadOnlyList<Guid>>
+        {
+            ["bertram gilfoyle"] = [memberKey],
+            ["Bertram   Gilfoyle"] = [memberKey]
+        });
+
+        var result = Assert.Single(matcher.MatchPresenters([new ImportedPresenterPlan("speaker-1", "Bertram   Gilfoyle", null)]));
+
+        Assert.Equal(memberKey, result.MatchedMemberKey);
+    }
+
+    private static PresenterMemberMatcher CreateMatcher(IReadOnlyDictionary<string, IReadOnlyList<Guid>> resultsBySearchTerm)
+    {
+        return new PresenterMemberMatcher(searchTerm =>
+            resultsBySearchTerm.TryGetValue(searchTerm, out var result)
+                ? result
+                : []);
+    }
+
+}