Add ability to ignore old updates (#50)

mkotb · web-flow · commit 599fe138b15d · 2020-03-03T20:57:04.000-08:00
diff --git a/jtelegrambotapi-core/src/main/java/com/jtelegram/api/update/PollingUpdateProvider.java b/jtelegrambotapi-core/src/main/java/com/jtelegram/api/update/PollingUpdateProvider.java
@@ -23,6 +23,18 @@ public class PollingUpdateProvider implements UpdateProvider {
     private int sleepInterval = 50;
     @Builder.Default
     private int timeout = 10;
+    /**
+     * The max age (in seconds) that an update can be.
+     *
+     * If the data is available and the update is older
+     * than maxUpdateAge seconds, then it is silently ignored.
+     *
+     * By default, this feature is disabled.
+     *
+     * @see com.jtelegram.api.update.Update.TimeSensitiveUpdate
+     */
+    @Builder.Default
+    private long maxUpdateAge = -1;
     @Singular
     private List<UpdateType> allowedUpdates;
     @Builder.Default
diff --git a/jtelegrambotapi-core/src/main/java/com/jtelegram/api/update/PollingUpdateRunnable.java b/jtelegrambotapi-core/src/main/java/com/jtelegram/api/update/PollingUpdateRunnable.java
@@ -8,6 +8,7 @@
 import okhttp3.Response;
 
 import java.io.IOException;
+import java.util.concurrent.TimeUnit;
 import java.net.SocketTimeoutException;
 import java.util.Objects;
 import java.util.stream.Stream;
@@ -57,18 +58,43 @@ public void run() {
     public void handleUpdates(Update[] updates) {
         for (Update update : updates) {
             if (update != null) {
-                handleUpdate(bot, UpdateType.from(update.getClass()), update);
+                handleUpdate(bot, owner.getMaxUpdateAge(), UpdateType.from(update.getClass()), update);
             }
         }
 
         offset = Stream.of(updates).filter(Objects::nonNull).mapToInt(Update::getUpdateId).max().orElse(offset - 1) + 1;
     }
 
+    // legacy method for mismatched core + webhooks
     public static <T extends Update> void handleUpdate(TelegramBot bot, UpdateType<T> type, Update update) {
+        handleUpdate(bot, -1L, type, update);
+    }
+
+    public static <T extends Update> void handleUpdate(TelegramBot bot, long maxAge, UpdateType<T> type, Update update) {
         if (type != null) {
             Class<T> clazz = type.getUpdateClass();
 
+            if (isTooOld(update, maxAge)) {
+                return;
+            }
+
             bot.getEventRegistry().dispatch(type.getEventFunction().apply(bot, clazz.cast(update)));
         }
     }
+
+    private static boolean isTooOld(Update update, long maxDistance) {
+        if (maxDistance <= 0) {
+            return false;
+        }
+
+        if (!(update instanceof Update.TimeSensitiveUpdate)) {
+            return false;
+        }
+
+        long eventTime = ((Update.TimeSensitiveUpdate) update).getEventTime();
+        long currentUnixTime = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis());
+        long timeDistance = Math.max(0, currentUnixTime - eventTime);
+
+        return timeDistance >= maxDistance;
+    }
 }
diff --git a/jtelegrambotapi-core/src/main/java/com/jtelegram/api/update/Update.java b/jtelegrambotapi-core/src/main/java/com/jtelegram/api/update/Update.java
@@ -21,10 +21,27 @@
 public class Update {
     private int updateId;
 
+    public static abstract class TimeSensitiveUpdate extends Update {
+        /**
+         * @return The relevant unix time when the update
+         * should be compared to.
+         */
+        public abstract long getEventTime();
+
+        protected long getDateFromMessage(Message message) {
+            return message.getForwardSignature() != null ? message.getForwardDate() : message.getDate();
+        }
+    }
+
     @Getter
     @ToString(callSuper = true)
-    public static class ChannelPostUpdate extends Update {
+    public static class ChannelPostUpdate extends TimeSensitiveUpdate {
         private Message channelPost;
+
+        @Override
+        public long getEventTime() {
+            return getDateFromMessage(channelPost);
+        }
     }
 
     @Getter
@@ -35,14 +52,24 @@ public static class ChosenInlineResultUpdate extends Update {
 
     @Getter
     @ToString(callSuper = true)
-    public static class EditedChannelPostUpdate extends Update {
+    public static class EditedChannelPostUpdate extends TimeSensitiveUpdate {
         private Message editedChannelPost;
+
+        @Override
+        public long getEventTime() {
+            return editedChannelPost.getEditDate();
+        }
     }
 
     @Getter
     @ToString(callSuper = true)
-    public static class EditedMessageUpdate extends Update {
+    public static class EditedMessageUpdate extends TimeSensitiveUpdate {
         private Message editedMessage;
+
+        @Override
+        public long getEventTime() {
+            return editedMessage.getEditDate();
+        }
     }
 
     @Getter
@@ -59,8 +86,13 @@ public static class CallbackQueryUpdate extends Update {
 
     @Getter
     @ToString(callSuper = true)
-    public static class MessageUpdate extends Update {
+    public static class MessageUpdate extends TimeSensitiveUpdate {
         private Message message;
+
+        @Override
+        public long getEventTime() {
+            return getDateFromMessage(message);
+        }
     }
 
     @Getter
diff --git a/jtelegrambotapi-webhooks/src/main/java/com/jtelegram/api/webhooks/WebhookUpdateProvider.java b/jtelegrambotapi-webhooks/src/main/java/com/jtelegram/api/webhooks/WebhookUpdateProvider.java
@@ -7,10 +7,7 @@
 import com.jtelegram.api.message.input.file.LocalInputFile;
 import com.jtelegram.api.requests.webhooks.DeleteWebhook;
 import com.jtelegram.api.requests.webhooks.SetWebhook;
-import com.jtelegram.api.update.PollingUpdateRunnable;
-import com.jtelegram.api.update.Update;
-import com.jtelegram.api.update.UpdateProvider;
-import com.jtelegram.api.update.UpdateType;
+import com.jtelegram.api.update.*;
 import io.vertx.core.AsyncResult;
 import io.vertx.core.Vertx;
 import io.vertx.core.http.HttpServer;
@@ -43,14 +40,18 @@ public class WebhookUpdateProvider implements UpdateProvider {
     private List<UpdateType> updateTypes;
     private Integer maxConnections;
     private Integer retryAfter;
+    /**
+     * @see PollingUpdateProvider#getMaxUpdateAge()
+     */
+    private long maxUpdateAge = -1;
     private Consumer<TelegramException> errorHandler = ErrorLogger.builder()
             .identifier("Webhook Update Provider")
             .build();
 
     @Builder
     public WebhookUpdateProvider(HttpServerOptions serverOptions, File selfSignedCertificate,
                                  List<UpdateType> updateTypes, Integer maxConnections, Integer retryAfter,
-                                 Consumer<TelegramException> errorHandler) throws InterruptedException, FailBindingException {
+                                 Long maxUpdateAge, Consumer<TelegramException> errorHandler) throws InterruptedException, FailBindingException {
         if (!serverOptions.isSsl()) {
             throw new IllegalArgumentException("Http Server must be SSL!");
         }
@@ -63,6 +64,10 @@ public WebhookUpdateProvider(HttpServerOptions serverOptions, File selfSignedCer
             this.errorHandler = errorHandler;
         }
 
+        if (maxUpdateAge != null) {
+            this.maxUpdateAge = maxUpdateAge;
+        }
+
         this.updateTypes = updateTypes;
         this.maxConnections = maxConnections;
         this.retryAfter = retryAfter;
@@ -80,7 +85,7 @@ public WebhookUpdateProvider(HttpServerOptions serverOptions, File selfSignedCer
                         Update update = TelegramBotRegistry.GSON.fromJson(buffer.toString(), Update.class);
 
                         if (update != null) {
-                            PollingUpdateRunnable.handleUpdate(bot, UpdateType.from(update.getClass()), update);
+                            PollingUpdateRunnable.handleUpdate(bot, maxUpdateAge, UpdateType.from(update.getClass()), update);
                         }
                     } catch (TelegramException ex) {
                         this.errorHandler.accept(ex);
