✨ Select events by service

Author: oschrenk

Sources/Cli/Options.swift

@@ -85,6 +85,18 @@ struct EventOptions: ParsableArguments {
     valueName: "t"
   )) var selectTags: [String] = []
 
+  @Option(help: ArgumentHelp(
+    "Ignore events which services contain the service <s> " +
+      "A comma separated list of services",
+    valueName: "s"
+  )) var ignoreServices: [String] = []
+
+  @Option(help: ArgumentHelp(
+    "Select events which services contain the service <s> " +
+      "A comma separated list of services",
+    valueName: "s"
+  )) var selectServices: [String] = []
+
   @Option(help: ArgumentHelp(
     "Minimum (inclusive) number <n> of attendees",
     valueName: "n"

Sources/Filters/EventFilter.swift

@@ -179,6 +179,42 @@ enum EventFilter {
     }
   }
 
+  class IgnoreServices: EventFilterI {
+    let services: [String]
+
+    init(services: [String]) {
+      self.services = services
+    }
+
+    func accept(_ event: Event) -> Bool {
+      let intersection = Set(services).intersection(Set(event.services.keys))
+      let hasMatchingService = !intersection.isEmpty
+      return !hasMatchingService
+    }
+
+    var description: String {
+      return "EventFilter.IgnoreServices(\(services))"
+    }
+  }
+
+  class SelectServices: EventFilterI {
+    let services: [String]
+
+    init(services: [String]) {
+      self.services = services
+    }
+
+    func accept(_ event: Event) -> Bool {
+      let intersection = Set(services).intersection(Set(event.services.keys))
+      let hasMatchingService = !intersection.isEmpty
+      return hasMatchingService
+    }
+
+    var description: String {
+      return "EventFilter.SelectServices(\(services))"
+    }
+  }
+
   class Combined: EventFilterI {
     let filters: [EventFilterI]
 
@@ -195,6 +231,9 @@ enum EventFilter {
     }
   }
 
+  // ignoring cyclomatic_complexity, since they are
+  // required checks and just add filters
+  // swiftlint:disable:next cyclomatic_complexity
   static func build(
     opts: EventOptions
   ) -> (EventFilterI) {
@@ -229,6 +268,14 @@ enum EventFilter {
       add(EventFilter.SelectTags(tags: opts.selectTags))
     }
 
+    if !opts.ignoreServices.isEmpty {
+      add(EventFilter.IgnoreServices(services: opts.ignoreServices))
+    }
+
+    if !opts.selectServices.isEmpty {
+      add(EventFilter.SelectServices(services: opts.selectServices))
+    }
+
     if opts.minNumAttendees ?? -1 >= 0 {
       add(EventFilter.MinNumAttendees(count: opts.minNumAttendees!))
     }

Sources/Model/Event.swift

@@ -87,7 +87,8 @@ struct Event: Codable, ReverseCodable, Equatable {
     attendees: [String] = [],
     now: Date = Date(),
     startDate: Date = Date(),
-    endDate: Date = Date()
+    endDate: Date = Date(),
+    services: [String: String] = [:]
   ) -> Event {
     let cal = PlanCalendar.Unknown
     let title = Title(text: title)
@@ -99,7 +100,6 @@ struct Event: Codable, ReverseCodable, Equatable {
     )
     let location = ""
     let meeting = Meeting(organizer: "", attendees: attendees)
-    let services: [String: String] = [:]
 
     return Event(
       id: id,

Tests/EventFilterTest.swift

@@ -43,6 +43,38 @@ import Testing
     #expect(actual == expected)
   }
 
+  @Test func testIgnoreServicesNoServices() {
+    let event = Event.generate()
+    let expected = true
+    let actual = EventFilter.IgnoreServices(services: []).accept(event)
+
+    #expect(actual == expected)
+  }
+
+  @Test func testIgnoreServiceMatchingService() {
+    let event = Event.generate(services: ["zoom": "example"])
+    let expected = false
+    let actual = EventFilter.IgnoreServices(services: ["zoom"]).accept(event)
+
+    #expect(actual == expected)
+  }
+
+  @Test func testIgnoreServiceNotMatchingServices() {
+    let event = Event.generate(services: ["zoom": "example"])
+    let expected = true
+    let actual = EventFilter.IgnoreServices(services: ["teams"]).accept(event)
+
+    #expect(actual == expected)
+  }
+
+  @Test func testSelectServicesMatchingServices() {
+    let event = Event.generate(services: ["zoom": "example"])
+    let expected = true
+    let actual = EventFilter.SelectServices(services: ["zoom"]).accept(event)
+
+    #expect(actual == expected)
+  }
+
   @Test func testIgnoreAnAllDayEvent() {
     let event = Event.generate(allDay: true)
     let expected = false