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         if (outputWriter instanceof PlainTextWriter writer) {
  31             var errors = getErrorMessagesFromSendMessageResults(sendMessageResults.results());
  32             printSendMessageResultErrors(writer, errors);
  33             writer.println("{}", sendMessageResults.timestamp());
  34         } else {
  35             final var writer = (JsonWriter) outputWriter;
  36             var results = getJsonSendMessageResults(sendMessageResults.results());
  37             writer.write(Map.of("timestamp", sendMessageResults.timestamp(), "results", results));
  38         }
  39     }
  40
  41     public static void outputResult(
  42             final OutputWriter outputWriter, final SendMessageResults sendMessageResults
  43     ) throws CommandException {
  44         if (outputWriter instanceof PlainTextWriter writer) {
  45             var errors = getErrorMessagesFromSendMessageResults(sendMessageResults.results());
  46             printSendMessageResultErrors(writer, errors);
  47             writer.println("{}", sendMessageResults.timestamp());
  48         } else {
  49             final var writer = (JsonWriter) outputWriter;
  50             var results = getJsonSendMessageResults(sendMessageResults.results());
  51             writer.write(Map.of("timestamp", sendMessageResults.timestamp(), "results", results));
  52         }
  53         if (!sendMessageResults.hasSuccess()) {
  54             if (sendMessageResults.hasOnlyUntrustedIdentity()) {
  55                 throw new UntrustedKeyErrorException("Failed to send message due to untrusted identities");
  56             } else if (sendMessageResults.hasOnlyRateLimitFailure()) {
  57                 throw new RateLimitErrorException("Failed to send message due to rate limiting",
  58                         new RateLimitException(0));
  59             } else {
  60                 throw new UserErrorException("Failed to send message");
  61             }
  62         }
  63     }
  64
  65     public static List<String> getErrorMessagesFromSendMessageResults(final Map<RecipientIdentifier, List<SendMessageResult>> mapResults) {
  66         return mapResults.entrySet()
  67                 .stream()
  68                 .flatMap(entry -> entry.getValue()
  69                         .stream()
  70                         .map(SendMessageResultUtils::getErrorMessageFromSendMessageResult)
  71                         .filter(Objects::nonNull)
  72                         .map(error -> entry.getKey().getIdentifier() + ": " + error))
  73                 .toList();
  74     }
  75
  76     public static List<String> getErrorMessagesFromSendMessageResults(Collection<SendMessageResult> results) {
  77         return results.stream()
  78                 .map(SendMessageResultUtils::getErrorMessageFromSendMessageResult)
  79                 .filter(Objects::nonNull)
  80                 .toList();
  81     }
  82
  83     public static String getErrorMessageFromSendMessageResult(SendMessageResult result) {
  84         var identifier = result.address().getLegacyIdentifier();
  85         if (result.proofRequiredFailure() != null) {
  86             final var failure = result.proofRequiredFailure();
  87             return String.format(
  88                     "CAPTCHA proof required for sending to \"%s\", available options \"%s\" with challenge token \"%s\", or wait \"%d\" seconds.\n"
  89                             + (
  90                             failure.getOptions().contains(ProofRequiredException.Option.RECAPTCHA)
  91                                     ? """
  92                                       To get the captcha token, go to https://signalcaptchas.org/challenge/generate.html
  93                                       Check the developer tools (F12) console for a failed redirect to signalcaptcha://
  94                                       Everything after signalcaptcha:// is the captcha token.
  95                                       Use the following command to submit the captcha token:
  96                                       signal-cli submitRateLimitChallenge --challenge CHALLENGE_TOKEN --captcha CAPTCHA_TOKEN"""
  97                                     : ""
  98                     ),
  99                     identifier,
 100                     failure.getOptions()
 101                             .stream()
 102                             .map(ProofRequiredException.Option::toString)
 103                             .collect(Collectors.joining(", ")),
 104                     failure.getToken(),
 105                     failure.getRetryAfterSeconds());
 106         } else if (result.isNetworkFailure()) {
 107             return String.format("Network failure for \"%s\"", identifier);
 108         } else if (result.isRateLimitFailure()) {
 109             return String.format("Rate limit failure for \"%s\"", identifier);
 110         } else if (result.isUnregisteredFailure()) {
 111             return String.format("Unregistered user \"%s\"", identifier);
 112         } else if (result.isIdentityFailure()) {
 113             return String.format("Untrusted Identity for \"%s\"", identifier);
 114         }
 115         return null;
 116     }
 117
 118     public static void printSendMessageResultErrors(PlainTextWriter writer, List<String> errors) {
 119         if (errors.isEmpty()) {
 120             return;
 121         }
 122         writer.println("Failed to send (some) messages:");
 123         for (var error : errors) {
 124             writer.println(error);
 125         }
 126     }
 127
 128     private static List<JsonSendMessageResult> getJsonSendMessageResults(final Map<RecipientIdentifier, List<SendMessageResult>> mapResults) {
 129         return mapResults.entrySet().stream().flatMap(entry -> {
 130             final var groupId = entry.getKey() instanceof RecipientIdentifier.Group g ? g.groupId() : null;
 131             return entry.getValue().stream().map(r -> JsonSendMessageResult.from(r, groupId));
 132         }).toList();
 133     }
 134
 135     public static List<JsonSendMessageResult> getJsonSendMessageResults(Collection<SendMessageResult> results) {
 136         return results.stream().map(JsonSendMessageResult::from).toList();
 137     }
 138 }