nmode's Git Repositories - signal-cli/blob - src/main/java/org/asamk/signal/util/SendMessageResultUtils.java

   1 package org.asamk.signal.util;
   2
   3 import org.asamk.signal.commands.exceptions.CommandException;
   4 import org.asamk.signal.commands.exceptions.RateLimitErrorException;
   5 import org.asamk.signal.commands.exceptions.UntrustedKeyErrorException;
   6 import org.asamk.signal.commands.exceptions.UserErrorException;
   7 import org.asamk.signal.json.JsonSendMessageResult;
   8 import org.asamk.signal.manager.api.ProofRequiredException;
   9 import org.asamk.signal.manager.api.RateLimitException;
  10 import org.asamk.signal.manager.api.RecipientIdentifier;
  11 import org.asamk.signal.manager.api.SendGroupMessageResults;
  12 import org.asamk.signal.manager.api.SendMessageResult;
  13 import org.asamk.signal.manager.api.SendMessageResults;
  14 import org.asamk.signal.output.JsonWriter;
  15 import org.asamk.signal.output.OutputWriter;
  16 import org.asamk.signal.output.PlainTextWriter;
  17
  18 import java.util.Collection;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Objects;
  22 import java.util.stream.Collectors;
  23
  24 public class SendMessageResultUtils {
  25
  26     private SendMessageResultUtils() {
  27     }
  28
  29     public static void outputResult(final OutputWriter outputWriter, final SendGroupMessageResults sendMessageResults) {
  30         switch (outputWriter) {
  31             case PlainTextWriter writer -> {
  32                 var errors = getErrorMessagesFromSendMessageResults(sendMessageResults.results());
  33                 printSendMessageResultErrors(writer, errors);
  34                 writer.println("{}", sendMessageResults.timestamp());
  35             }
  36             case JsonWriter writer -> {
  37                 var results = getJsonSendMessageResults(sendMessageResults.results());
  38                 writer.write(Map.of("timestamp", sendMessageResults.timestamp(), "results", results));
  39             }
  40         }
  41     }
  42
  43     public static void outputResult(
  44             final OutputWriter outputWriter, final SendMessageResults sendMessageResults
  45     ) throws CommandException {
  46         switch (outputWriter) {
  47             case PlainTextWriter writer -> {
  48                 var errors = getErrorMessagesFromSendMessageResults(sendMessageResults.results());
  49                 printSendMessageResultErrors(writer, errors);
  50                 writer.println("{}", sendMessageResults.timestamp());
  51             }
  52             case JsonWriter writer -> {
  53                 var results = getJsonSendMessageResults(sendMessageResults.results());
  54                 writer.write(Map.of("timestamp", sendMessageResults.timestamp(), "results", results));
  55             }
  56         }
  57         if (!sendMessageResults.hasSuccess()) {
  58             if (sendMessageResults.hasOnlyUntrustedIdentity()) {
  59                 throw new UntrustedKeyErrorException("Failed to send message due to untrusted identities");
  60             } else if (sendMessageResults.hasOnlyRateLimitFailure()) {
  61                 throw new RateLimitErrorException("Failed to send message due to rate limiting",
  62                         new RateLimitException(0));
  63             } else {
  64                 throw new UserErrorException("Failed to send message");
  65             }
  66         }
  67     }
  68
  69     public static List<String> getErrorMessagesFromSendMessageResults(final Map<RecipientIdentifier, List<SendMessageResult>> mapResults) {
  70         return mapResults.entrySet()
  71                 .stream()
  72                 .flatMap(entry -> entry.getValue()
  73                         .stream()
  74                         .map(SendMessageResultUtils::getErrorMessageFromSendMessageResult)
  75                         .filter(Objects::nonNull)
  76                         .map(error -> entry.getKey().getIdentifier() + ": " + error))
  77                 .toList();
  78     }
  79
  80     public static List<String> getErrorMessagesFromSendMessageResults(Collection<SendMessageResult> results) {
  81         return results.stream()
  82                 .map(SendMessageResultUtils::getErrorMessageFromSendMessageResult)
  83                 .filter(Objects::nonNull)
  84                 .toList();
  85     }
  86
  87     public static String getErrorMessageFromSendMessageResult(SendMessageResult result) {
  88         var identifier = result.address().getLegacyIdentifier();
  89         if (result.proofRequiredFailure() != null) {
  90             final var failure = result.proofRequiredFailure();
  91             return String.format(
  92                     "CAPTCHA proof required for sending to \"%s\", available options \"%s\" with challenge token \"%s\", or wait \"%d\" seconds.\n"
  93                             + (
  94                             failure.getOptions().contains(ProofRequiredException.Option.RECAPTCHA)
  95                                     ? """
  96                                       To get the captcha token, go to https://signalcaptchas.org/challenge/generate.html
  97                                       After solving the captcha, right-click on the "Open Signal" link and copy the link.
  98                                       Use the following command to submit the captcha token:
  99                                       signal-cli submitRateLimitChallenge --challenge CHALLENGE_TOKEN --captcha CAPTCHA_TOKEN"""
 100                                     : ""
 101                     ),
 102                     identifier,
 103                     failure.getOptions()
 104                             .stream()
 105                             .map(ProofRequiredException.Option::toString)
 106                             .collect(Collectors.joining(", ")),
 107                     failure.getToken(),
 108                     failure.getRetryAfterSeconds());
 109         } else if (result.isNetworkFailure()) {
 110             return String.format("Network failure for \"%s\"", identifier);
 111         } else if (result.isRateLimitFailure()) {
 112             return String.format("Rate limit failure for \"%s\"", identifier);
 113         } else if (result.isUnregisteredFailure()) {
 114             return String.format("Unregistered user \"%s\"", identifier);
 115         } else if (result.isIdentityFailure()) {
 116             return String.format("Untrusted Identity for \"%s\"", identifier);
 117         }
 118         return null;
 119     }
 120
 121     public static void printSendMessageResultErrors(PlainTextWriter writer, List<String> errors) {
 122         if (errors.isEmpty()) {
 123             return;
 124         }
 125         writer.println("Failed to send (some) messages:");
 126         for (var error : errors) {
 127             writer.println(error);
 128         }
 129     }
 130
 131     private static List<JsonSendMessageResult> getJsonSendMessageResults(final Map<RecipientIdentifier, List<SendMessageResult>> mapResults) {
 132         return mapResults.entrySet().stream().flatMap(entry -> {
 133             final var groupId = entry.getKey() instanceof RecipientIdentifier.Group g ? g.groupId() : null;
 134             return entry.getValue().stream().map(r -> JsonSendMessageResult.from(r, groupId));
 135         }).toList();
 136     }
 137
 138     public static List<JsonSendMessageResult> getJsonSendMessageResults(Collection<SendMessageResult> results) {
 139         return results.stream().map(JsonSendMessageResult::from).toList();
 140     }
 141 }