automatically unfollow closed and inactive accounts - closes #16379

app/controllers/Relation.scala

@@ -77,13 +77,16 @@ final class Relation(env: Env, apiC: => Api) extends LilaController(env):
   def following(username: UserStr, page: Int) = Open:
     Reasonable(page, Max(20)):
       Found(meOrFetch(username)): user =>
-        RelatedPager(api.followingPaginatorAdapter(user.id), page).flatMap: pag =>
-          negotiate(
+        for
+          _   <- (page == 1).so(api.unfollowInactiveAccounts(user.id))
+          pag <- RelatedPager(api.followingPaginatorAdapter(user.id), page)
+          res <- negotiate(
             if ctx.is(user) || isGrantedOpt(_.CloseAccount)
             then Ok.page(views.relation.friends(user, pag))
             else Found(ctx.me)(me => Redirect(routes.Relation.following(me.username))),
             Ok(jsonRelatedPaginator(pag))
           )
+        yield res
 
   def followers(username: UserStr, page: Int) = Open:
     negotiateJson:

modules/relation/src/main/RelationApi.scala

@@ -78,6 +78,18 @@ final class RelationApi(
 
   def countFollowing(userId: UserId) = countFollowingCache.get(userId)
 
+  private val unfollowInactiveAccountsOnceEvery = scalalib.cache.OnceEvery[UserId](1.hour)
+
+  def unfollowInactiveAccounts(userId: UserId, since: Instant = nowInstant.minusYears(2)): Fu[List[UserId]] =
+    unfollowInactiveAccountsOnceEvery(userId).so:
+      for
+        following <- fetchFollowing(userId)
+        inactive  <- userApi.filterClosedOrInactiveIds(since)(following)
+        _ <- inactive.nonEmpty.so:
+          countFollowingCache.update(userId, _ - inactive.size)
+          repo.unfollowMany(userId, inactive)
+      yield inactive
+
   def reachedMaxFollowing(userId: UserId): Fu[Boolean] =
     countFollowingCache.get(userId).map(config.maxFollow <= _)
 
@@ -128,23 +140,12 @@ final class RelationApi(
       }
     })
 
-  private val limitFollowRateLimiter = lila.memo.RateLimit[UserId](
-    credits = 1,
-    duration = 1 hour,
-    key = "follow.limit.cleanup"
-  )
-
   private def limitFollow(u: UserId) =
     countFollowing(u).flatMap: nb =>
-      (config.maxFollow < nb).so {
-        limitFollowRateLimiter(u, fuccess(Nil)):
-          fetchFollowing(u).flatMap(userApi.filterClosedOrInactiveIds(nowInstant.minusDays(90)))
-        .flatMap:
-          case Nil => repo.drop(u, Follow, nb - config.maxFollow.value)
-          case inactiveIds =>
-            for _ <- repo.unfollowMany(u, inactiveIds)
-            yield countFollowingCache.update(u, _ - inactiveIds.size)
-      }
+      (config.maxFollow < nb).so:
+        unfollowInactiveAccounts(u, nowInstant.minusDays(90)).flatMap:
+          _.isEmpty.so:
+            repo.drop(u, Follow, nb - config.maxFollow.value)
 
   private def limitBlock(u: UserId) =
     countBlocking(u).flatMap: nb =>