예제 #1
0
 public void onTimeoutExpire(User user, Server server) {
   String serverId = server.getId();
   TempServerConfig serverConfig = serverStorage.get(serverId);
   if (serverConfig == null) {
     serverConfig = new TempServerConfig(serverId);
     serverStorage.put(serverId, serverConfig);
   }
   ServerTimeoutStorage storage = serverConfig.getServerTimeouts();
   if (storage != null) {
     ServerTimeout timeout = storage.getTimeouts().remove(user.getId());
     if (timeout != null) {
       saveServerConfig(serverConfig);
       LOGGER.info(
           "Expiring timeout for {} ({}) in {} ({})",
           user.getUsername(),
           user.getId(),
           server.getName(),
           server.getId());
       if (apiClient.getUserById(user.getId(), server) != NO_USER) {
         apiClient.sendMessage(
             loc.localize("message.mod.timeout.expire", user.getId()), server.getId());
       }
       removeTimeoutRole(user, server, apiClient.getChannelById(server.getId()));
       return;
     }
   }
   LOGGER.warn(
       "Unable to expire: find server or timeout entry for {} ({}) in {} ({})",
       user.getUsername(),
       user.getId(),
       server.getName(),
       server.getId());
 }
예제 #2
0
 private void refreshTimeoutOnEvade(User user, Server server) {
   ServerTimeout timeout =
       SafeNav.of(serverStorage.get(server.getId()))
           .next(TempServerConfig::getServerTimeouts)
           .next(ServerTimeoutStorage::getTimeouts)
           .next(timeouts -> timeouts.get(user.getId()))
           .get();
   if (timeout == null) {
     LOGGER.warn(
         "Attempted to refresh a timeout on a user who was not timed out! {} ({})",
         user.getUsername(),
         user.getId());
     return;
   }
   LOGGER.info(
       "User {} ({}) attempted to evade a timeout on {} ({})!",
       user.getUsername(),
       user.getId(),
       server.getName(),
       server.getId());
   Channel channel = apiClient.getChannelById(server.getId(), server);
   apiClient.sendMessage(
       loc.localize(
           "listener.mod.timeout.on_evasion",
           user.getId(),
           formatDuration(Duration.between(Instant.now(), timeout.getEndTime())),
           formatInstant(timeout.getEndTime())),
       channel);
   applyTimeoutRole(user, server, channel);
 }
예제 #3
0
  private void ban(MessageContext context, String args) {
    if (args.isEmpty()) {
      return;
    }
    String[] split = args.split(" ");
    List<String> banned = new ArrayList<>();
    List<String> failed = new ArrayList<>();
    Channel channel = context.getChannel();
    for (String userStr : split) {
      User user = findUser(context, userStr);
      String userId = user.getId();
      if (user == NO_USER) {
        userId = userStr;
      }

      if (banChecked(channel, context.getAuthor(), user, context.getServer())) {
        banned.add(userId + " " + user.getUsername());
      } else {
        failed.add(userId + " " + user.getUsername());
      }
    }

    if (channel.getId() != null) {
      StringJoiner joiner = new StringJoiner("\n");
      for (String s : banned) {
        String[] pair = s.split(" ", 2);
        joiner.add(loc.localize("commands.mod.ban.response", pair[1], pair[0]));
      }
      apiClient.sendMessage(joiner.toString(), channel);
    }
  }
예제 #4
0
 public boolean applyTimeout(
     User issuingUser, Channel noticeChannel, Server server, User user, Duration duration) {
   String serverId = server.getId();
   if (duration != null && !duration.isNegative() && !duration.isZero()) {
     ServerTimeout timeout =
         new ServerTimeout(
             duration,
             Instant.now(),
             user.getId(),
             serverId,
             user.getUsername(),
             issuingUser.getId());
     TempServerConfig serverConfig = serverStorage.get(serverId);
     if (serverConfig == null) {
       serverConfig = new TempServerConfig(serverId);
       serverStorage.put(serverId, serverConfig);
     }
     ServerTimeoutStorage storage = serverConfig.getServerTimeouts();
     if (storage == null) {
       storage = new ServerTimeoutStorage();
       serverConfig.setServerTimeouts(storage);
     }
     if (applyTimeoutRole(user, server, noticeChannel)) {
       storage.getTimeouts().put(user.getId(), timeout);
       ScheduledFuture future =
           timeoutService.schedule(
               () -> onTimeoutExpire(user, server), duration.getSeconds(), TimeUnit.SECONDS);
       timeout.setTimerFuture(future);
       saveServerConfig(serverConfig);
       String durationStr = formatDuration(duration);
       String instantStr = formatInstant(timeout.getEndTime());
       String msg =
           loc.localize(
               "commands.mod.timeout.response",
               user.getUsername(),
               user.getId(),
               durationStr,
               instantStr);
       apiClient.sendMessage(msg, noticeChannel);
       LOGGER.info(
           "[{}] '{}': Timing out {} ({}) for {} (until {}), issued by {} ({})",
           serverId,
           server.getName(),
           user.getUsername(),
           user.getId(),
           durationStr,
           instantStr,
           issuingUser.getUsername(),
           issuingUser.getId());
     }
     //  No else with error - applyTimeoutRole does that for us
     return true;
   } else {
     LOGGER.warn("Invalid duration format");
   }
   return false;
 }
예제 #5
0
 private String userToResult(User user) {
   return loc.localize(
       "commands.admin.find.response.entry",
       user.getUsername(),
       user.getId(),
       user.getDiscriminator());
 }
예제 #6
0
 private void stopTimeout(MessageContext context, String args) {
   if (args.isEmpty()) {
     apiClient.sendMessage(
         loc.localize("commands.mod.stoptimeout.response.invalid"), context.getChannel());
     return;
   }
   String uid = args;
   if (uid.length() > 4) {
     if (uid.startsWith("<@")) {
       uid = uid.substring(2, uid.length() - 1);
     }
     Server server = context.getServer();
     User user = apiClient.getUserById(uid, server);
     if (user == NO_USER) {
       user = new User("UNKNOWN", uid, "", null);
     }
     LOGGER.info(
         "{} ({}) is attempting to cancel timeout for {} ({}) in {} ({})",
         context.getAuthor().getUsername(),
         context.getAuthor().getId(),
         user.getUsername(),
         user.getId(),
         server.getName(),
         server.getId());
     cancelTimeout(user, server, context.getChannel());
   } else {
     apiClient.sendMessage(
         loc.localize("commands.mod.stoptimeout.response.invalid"), context.getChannel());
   }
 }
예제 #7
0
 public void cancelTimeout(User user, Server server, Channel invocationChannel) {
   String serverId = server.getId();
   TempServerConfig serverConfig = serverStorage.get(serverId);
   if (serverConfig == null) {
     serverConfig = new TempServerConfig(serverId);
     serverStorage.put(serverId, serverConfig);
   }
   ServerTimeoutStorage storage = serverConfig.getServerTimeouts();
   removeTimeoutRole(user, server, apiClient.getChannelById(serverId));
   if (storage != null) {
     ServerTimeout timeout = storage.getTimeouts().remove(user.getId());
     saveServerConfig(serverConfig);
     if (timeout != null) {
       SafeNav.of(timeout.getTimerFuture()).ifPresent(f -> f.cancel(true));
       LOGGER.info(
           "Cancelling timeout for {} ({}) in {} ({})",
           user.getUsername(),
           user.getId(),
           server.getName(),
           serverId);
       apiClient.sendMessage(
           loc.localize("commands.mod.stoptimeout.response", user.getUsername(), user.getId()),
           invocationChannel);
       return;
     }
   }
   LOGGER.warn(
       "Unable to cancel: cannot find server or timeout entry for {} ({}) in {} ({})",
       user.getUsername(),
       user.getId(),
       server.getName(),
       server.getId());
   apiClient.sendMessage(
       loc.localize(
           "commands.mod.stoptimeout.response.not_found", user.getUsername(), user.getId()),
       invocationChannel);
 }
예제 #8
0
  private void timeout(MessageContext context, String args) {
    Channel channel = context.getChannel();
    if (!args.isEmpty()) {
      String[] split = args.split(" ", 2);
      String uid = split[0];
      if (uid.length() > 4) {
        if (uid.startsWith("<@!")) {
          uid = uid.substring(3, uid.length() - 1);
        } else if (uid.startsWith("<@")) {
          uid = uid.substring(2, uid.length() - 1);
        }
        if (!uid.matches("[0-9]+")) {
          apiClient.sendMessage(loc.localize("commands.mod.stoptimeout.response.not_id"), channel);
          return;
        }
        Server server = context.getServer();
        String serverId = server.getId();
        User user = apiClient.getUserById(uid, server);
        if (user == NO_USER) {
          user = new User("UNKNOWN", uid, "", null);
        }
        final User theUser = user;
        if (split.length == 2) {
          if (bot.getConfig().isAdmin(user.getId())) {
            apiClient.sendMessage(
                "```API error: Server returned HTTP: 403 Forbidden. Check bot " + "permissions```",
                channel);
            return;
          }

          Duration duration = parseDuration(split[1]);
          if (applyTimeout(context.getAuthor(), channel, server, user, duration)) {
            return;
          }
        } else if (split.length == 1) {
          if (isUserTimedOut(user, server)) {
            ServerTimeout timeout =
                SafeNav.of(serverStorage.get(serverId))
                    .next(TempServerConfig::getServerTimeouts)
                    .next(ServerTimeoutStorage::getTimeouts)
                    .next(m -> m.get(theUser.getId()))
                    .get();
            //  Timeout cannot be null since we just checked
            User timeoutIssuer = apiClient.getUserById(timeout.getIssuedByUserId(), server);
            apiClient.sendMessage(
                loc.localize(
                    "commands.mod.timeout.response.check",
                    user.getUsername(),
                    user.getId(),
                    formatDuration(Duration.between(Instant.now(), timeout.getEndTime())),
                    formatInstant(timeout.getEndTime()),
                    timeoutIssuer.getUsername(),
                    timeout.getIssuedByUserId()),
                channel);
          } else {
            apiClient.sendMessage(
                loc.localize(
                    "commands.mod.timeout.response.check.not_found",
                    user.getUsername(),
                    user.getId()),
                channel);
          }
          return;
        } else {
          LOGGER.warn("Split length not 1 or 2, was {}: '{}'", split.length, args);
        }
      } else {
        LOGGER.warn("UID/mention not long enough: '{}'", args);
      }
    } else {
      LOGGER.warn("Args was empty");
    }
    apiClient.sendMessage(loc.localize("commands.mod.timeout.response.invalid"), channel);
  }
예제 #9
0
 private void setNick(MessageContext context, String args) {
   if (context.getServer() == null || context.getServer() == NO_SERVER) {
     return;
   }
   String serverId = context.getServer().getId();
   Channel channel = context.getChannel();
   String[] split = args.split(" ", 2);
   String newNickname;
   if (split.length == 1) {
     //  Clearing nickname, set to empty string
     newNickname = "";
   } else {
     newNickname = split[1];
   }
   User[] mentions = context.getMessage().getMentions();
   if (mentions.length == 0) {
     apiClient.sendMessage(loc.localize("commands.mod.setnick.response.blank"), channel);
   }
   User target = mentions[0];
   Map<String, String> headers = new HashMap<>();
   headers.put(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType());
   headers.put(HttpHeaders.AUTHORIZATION, apiClient.getToken());
   try {
     HttpResponse<JsonNode> response =
         Unirest.patch(
                 "https://discordapp.com/api/guilds/" + serverId + "/members/" + target.getId())
             .headers(headers)
             .body("{\"nick\":\"" + newNickname + "\"}")
             .asJson();
     int status = response.getStatus();
     if (status != 204) {
       if (status == 403) {
         apiClient.sendMessage(
             loc.localize("commands.mod.setnick.response.failed.no_perms"), channel);
       } else if (status == 404) {
         apiClient.sendMessage(
             loc.localize("commands.mod.setnick.response.failed.not_found"), channel);
       } else {
         apiClient.sendMessage(
             loc.localize(
                 "commands.mod.setnick.response.unknown_error",
                 status,
                 response.getStatusText(),
                 response.getBody().toString()),
             channel);
       }
     } else {
       if (newNickname.isEmpty()) {
         apiClient.sendMessage(
             loc.localize("commands.mod.setnick.response.removed", target.getUsername()), channel);
       } else {
         apiClient.sendMessage(
             loc.localize(
                 "commands.mod.setnick.response.changed", target.getUsername(), newNickname),
             channel);
       }
     }
   } catch (UnirestException e) {
     LOGGER.warn(
         "Exception while setting nickname for {} {} in {} {}",
         target.getUsername(),
         target.getId(),
         context.getServer().getName(),
         serverId);
     LOGGER.warn("Nickname set exception", e);
   }
 }
예제 #10
0
  public void loadServerConfig(Path path) {
    boolean purge = false;
    TempServerConfig config;
    ServerTimeoutStorage storage;
    try (Reader reader = Files.newBufferedReader(path, UTF_8)) {
      config = gson.fromJson(reader, TempServerConfig.class);
      serverStorage.put(config.getServerId(), config);
      storage = config.getServerTimeouts();
      if (storage != null) {
        Server server = apiClient.getServerByID(config.getServerId());
        if (server == NO_SERVER) {
          LOGGER.warn("Rejecting {} server storage file: server not found", config.getServerId());
          return;
        }
        LOGGER.info(
            "Loaded {} ({}) server storage file",
            server.getName(),
            server.getId(),
            storage.getTimeoutRoleId());
        //  Prune expired entries
        for (Iterator<Map.Entry<String, ServerTimeout>> iter =
                storage.getTimeouts().entrySet().iterator();
            iter.hasNext(); ) {
          Map.Entry<String, ServerTimeout> e = iter.next();
          ServerTimeout timeout = e.getValue();
          String userId = timeout.getUserId();
          User user = apiClient.getUserById(userId, server);
          if (!isUserTimedOut(userId, server.getId())) {
            //  Purge!
            purge = true;
            if (user == NO_USER) {
              LOGGER.info(
                  "Ending timeout for departed user {} ({}) in {} ({})",
                  timeout.getLastUsername(),
                  userId,
                  server.getName(),
                  server.getId());
              //
              // apiClient.sendMessage(loc.localize("message.mod.timeout.expire.not_found",
              //                                    user.getId()),
              //                                    server.getId());
              //  Don't need to remove the timeout role because leaving does that for us
            } else {
              //  Duplicated from onTimeoutExpire except without remove since we're removing in an
              // iter
              LOGGER.info(
                  "Expiring timeout for {} ({}) in {} ({})",
                  user.getUsername(),
                  user.getId(),
                  server.getName(),
                  server.getId());
              //  Only send message if they still have the role
              if (removeTimeoutRole(user, server, apiClient.getChannelById(server.getId()))) {
                //
                // apiClient.sendMessage(loc.localize("message.mod.timeout.expire",
                //                                        user.getId()),
                //                                        server.getId());
              }
            }
            SafeNav.of(timeout.getTimerFuture()).ifPresent(f -> f.cancel(true));
            iter.remove();
          } else {
            //  Start our futures
            Duration duration = Duration.between(Instant.now(), timeout.getEndTime());
            ScheduledFuture future =
                timeoutService.schedule(
                    () -> onTimeoutExpire(user, server), duration.getSeconds(), TimeUnit.SECONDS);
            timeout.setTimerFuture(future);
          }
        }
      }
    } catch (IOException | JsonParseException e) {
      LOGGER.warn("Unable to load server storage file " + path.toString(), e);
      return;
    }

    if (purge) {
      saveServerConfig(config);
    }
  }