Merge RSS and token sync

src/main/scala/PlexTokenDeleteSync.scala

@@ -1,4 +1,3 @@
-import WatchlistSync.fetchWatchlistFromRss
 import cats.data.EitherT
 import cats.effect.IO
 import cats.implicits._

src/main/scala/PlexTokenSync.scala

@@ -13,19 +13,24 @@ object PlexTokenSync extends PlexUtils with SonarrUtils with RadarrUtils {
 
   private val logger = LoggerFactory.getLogger(getClass)
 
-  def run(config: Configuration, client: HttpClient): IO[Unit] = {
+  def run(config: Configuration, client: HttpClient, firstRun: Boolean): IO[Unit] = {
     val result = for {
-      selfWatchlist <- getSelfWatchlist(config.plexConfiguration, client)
+      selfWatchlist <- if (firstRun)
+        getSelfWatchlist(config.plexConfiguration, client)
+      else
+        EitherT.pure[IO, Throwable](Set.empty[Item])
       _ = logger.info(s"Found ${selfWatchlist.size} items on user's watchlist using the plex token")
-      othersWatchlist <- if (config.plexConfiguration.skipFriendSync)
+      othersWatchlist <- if (!firstRun && config.plexConfiguration.skipFriendSync)
         EitherT.pure[IO, Throwable](Set.empty[Item])
       else
         getOthersWatchlist(config.plexConfiguration, client)
+      watchlistDatas <- EitherT[IO, Throwable, List[Set[Item]]](config.plexConfiguration.plexWatchlistUrls.map(fetchWatchlistFromRss(client)).toList.sequence.map(Right(_)))
+      watchlistData = watchlistDatas.flatten.toSet
       _ = logger.info(s"Found ${othersWatchlist.size} items on other available watchlists using the plex token")
       movies <- fetchMovies(client)(config.radarrConfiguration.radarrApiKey, config.radarrConfiguration.radarrBaseUrl, config.radarrConfiguration.radarrBypassIgnored)
       series <- fetchSeries(client)(config.sonarrConfiguration.sonarrApiKey, config.sonarrConfiguration.sonarrBaseUrl, config.sonarrConfiguration.sonarrBypassIgnored)
       allIds = movies ++ series
-      _ <- missingIds(client)(config)(allIds, selfWatchlist ++ othersWatchlist)
+      _ <- missingIds(client)(config)(allIds, selfWatchlist ++ othersWatchlist ++ watchlistData)
     } yield ()
 
     result.leftMap {

src/main/scala/Server.scala

@@ -1,6 +1,6 @@
 
 import cats.effect._
-import cats.implicits.catsSyntaxTuple4Parallel
+import cats.implicits.catsSyntaxTuple3Parallel
 import configuration.{Configuration, ConfigurationUtils, SystemPropertyReader}
 import http.HttpClient
 import org.slf4j.LoggerFactory
@@ -24,22 +24,13 @@ object Server extends IOApp {
     for {
       memoizedConfigIo <- ConfigurationUtils.create(configReader, httpClient).memoize
       result <- (
-        watchlistSync(memoizedConfigIo, httpClient),
         pingTokenSync(memoizedConfigIo, httpClient),
         plexTokenSync(memoizedConfigIo, httpClient),
         plexTokenDeleteSync(memoizedConfigIo, httpClient)
       ).parTupled.as(ExitCode.Success)
     } yield result
   }
 
-  private def watchlistSync(configIO: IO[Configuration], httpClient: HttpClient): IO[Unit] =
-    for {
-      config <- configIO
-      _ <- WatchlistSync.run(config, httpClient)
-      _ <- IO.sleep(config.refreshInterval)
-      _ <- watchlistSync(configIO, httpClient)
-    } yield ()
-
   private def pingTokenSync(configIO: IO[Configuration], httpClient: HttpClient): IO[Unit] =
     for {
       config <- configIO
@@ -48,10 +39,12 @@ object Server extends IOApp {
       _ <- pingTokenSync(configIO, httpClient)
     } yield ()
 
-  private def plexTokenSync(configIO: IO[Configuration], httpClient: HttpClient): IO[Unit] =
+  private def plexTokenSync(configIO: IO[Configuration], httpClient: HttpClient, firstRun: Boolean = true): IO[Unit] =
     for {
       config <- configIO
-      _ <- PlexTokenSync.run(config, httpClient)
+      _ <- PlexTokenSync.run(config, httpClient, firstRun)
+      _ <- IO.sleep(config.refreshInterval)
+      _ <- plexTokenSync(configIO, httpClient, firstRun = false)
     } yield ()
 
   private def plexTokenDeleteSync(configIO: IO[Configuration], httpClient: HttpClient): IO[Unit] =

src/test/scala/PlexTokenSyncSpec.scala

@@ -25,7 +25,7 @@ class PlexTokenSyncSpec extends AnyFlatSpec with Matchers with MockFactory {
     defaultRadarrMock(mockHttpClient)
     defaultSonarrMock(mockHttpClient)
 
-    val sync: Unit = PlexTokenSync.run(config, mockHttpClient).unsafeRunSync()
+    val sync: Unit = PlexTokenSync.run(config, mockHttpClient, firstRun = true).unsafeRunSync()
 
     sync shouldBe ()
   }
@@ -51,7 +51,7 @@ class PlexTokenSyncSpec extends AnyFlatSpec with Matchers with MockFactory {
       radarrBypassIgnored = false
     ),
     PlexConfiguration(
-      plexWatchlistUrls = Set(Uri.unsafeFromString("https://localhost:9090")),
+      plexWatchlistUrls = Set(),
       plexTokens = plexTokens,
       skipFriendSync = false
     ),