fix: syncing competitive approvals

Author: Golbolco

react_main/src/pages/Policy/Moderation/commands.js

@@ -932,6 +932,26 @@ export function useModCommands(argValues, commandRan, setResults) {
           .catch(errorAlert);
       },
     },
+    "Sync Competitive Approvals": {
+      perm: "adjustMinGames",
+      category: "Site Management",
+      args: [],
+      run: function () {
+        axios
+          .post("/api/mod/syncCompetitiveApprovals")
+          .then((res) => {
+            const count = res.data.restored;
+            siteInfo.showAlert(
+              count > 0
+                ? `Restored Competitive Player group to ${count} user(s) who had lost it.`
+                : "No users needed restoration; all qualifying users already have Competitive Player.",
+              "success"
+            );
+            commandRan();
+          })
+          .catch(errorAlert);
+      },
+    },
     "Toggle Ranked Setup": {
       perm: "approveRanked",
       category: "Setup Management",

routes/auth.js

@@ -514,6 +514,34 @@ async function authSuccess(req, uid, email, discordProfile) {
           }
         );
       }
+
+      // When auto-approval is on, ensure returning users who qualify get Competitive Player.
+      // This heals users who may have lost it (e.g. from cache/DB issues) and keeps them in sync.
+      if (await redis.getAutoApprovalEnabled()) {
+        const fullUser = await models.User.findOne({ id, deleted: false }).select("_id flagged");
+        if (fullUser && !fullUser.flagged) {
+          const rankedGroup = await models.Group.findOne({ name: "Ranked Player" }).select("_id");
+          const competitiveGroup = await models.Group.findOne({ name: "Competitive Player" }).select("_id");
+          if (rankedGroup && competitiveGroup) {
+            const inRanked = await models.InGroup.findOne({
+              user: fullUser._id,
+              group: rankedGroup._id,
+            });
+            const inCompetitive = await models.InGroup.findOne({
+              user: fullUser._id,
+              group: competitiveGroup._id,
+            });
+            if (inRanked && !inCompetitive) {
+              const inCompetitiveGroup = new models.InGroup({
+                user: fullUser._id,
+                group: competitiveGroup._id,
+              });
+              await inCompetitiveGroup.save();
+              await redis.cacheUserPermissions(id);
+            }
+          }
+        }
+      }
     }
 
     req.session.user = {

routes/mod.js

@@ -3788,4 +3788,65 @@ router.post("/autoApproval", async function (req, res) {
   }
 });
 
+router.post("/syncCompetitiveApprovals", async function (req, res) {
+  try {
+    var userId = await routeUtils.verifyLoggedIn(req);
+
+    if (!(await routeUtils.verifyPermission(res, userId, "adjustMinGames")))
+      return;
+
+    if (!(await redis.getAutoApprovalEnabled())) {
+      res.status(400).send(
+        "Auto-approval must be enabled. This sync only adds Competitive Player to users who have Ranked Player and would have been auto-approved."
+      );
+      return;
+    }
+
+    const rankedGroup = await models.Group.findOne({ name: "Ranked Player" }).select("_id");
+    const competitiveGroup = await models.Group.findOne({ name: "Competitive Player" }).select("_id");
+    if (!rankedGroup || !competitiveGroup) {
+      res.status(500).send("Required groups not found.");
+      return;
+    }
+
+    const inRanked = await models.InGroup.find({ group: rankedGroup._id })
+      .select("user")
+      .lean();
+    const rankedUserIds = inRanked.map((r) => r.user);
+    const inCompetitive = await models.InGroup.find({
+      group: competitiveGroup._id,
+      user: { $in: rankedUserIds },
+    })
+      .select("user")
+      .lean();
+    const competitiveUserIds = new Set(inCompetitive.map((c) => String(c.user)));
+
+    const usersToAdd = await models.User.find({
+      _id: { $in: rankedUserIds },
+      deleted: false,
+      flagged: { $ne: true },
+    })
+      .select("_id id")
+      .lean();
+
+    let restored = 0;
+    for (const user of usersToAdd) {
+      if (!competitiveUserIds.has(String(user._id))) {
+        await models.InGroup.create({
+          user: user._id,
+          group: competitiveGroup._id,
+        });
+        await redis.cacheUserPermissions(user.id);
+        restored++;
+      }
+    }
+
+    routeUtils.createModAction(userId, "Sync Competitive Approvals", [restored]);
+    res.json({ restored });
+  } catch (e) {
+    logger.error(e);
+    res.status(500).send("Error syncing competitive approvals.");
+  }
+});
+
 module.exports = router;