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