[AB-291] refactoring pagination to custom button pagination

adding mutes command
fixing edit message not considering components
reversing the origin comparison in a few button click listeners
fixing ordering of warnings and mutes from converter

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/listener/ConfirmationButtonClickedListener.java

@@ -103,7 +103,7 @@ public class ConfirmationButtonClickedListener implements ButtonClickedListener
 
     @Override
     public Boolean handlesEvent(ButtonClickedListenerModel model) {
-        return model.getOrigin().equals(CommandReceivedHandler.COMMAND_CONFIRMATION_ORIGIN);
+        return CommandReceivedHandler.COMMAND_CONFIRMATION_ORIGIN.equals(model.getOrigin());
     }
 
     @Override

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/job/PaginatorCleanupJob.java

@@ -0,0 +1,46 @@
+package dev.sheldan.abstracto.core.job;
+
+import dev.sheldan.abstracto.core.service.MessageService;
+import dev.sheldan.abstracto.core.service.PaginatorServiceBean;
+import dev.sheldan.abstracto.core.service.management.ComponentPayloadManagementService;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.quartz.DisallowConcurrentExecution;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.quartz.PersistJobDataAfterExecution;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.quartz.QuartzJobBean;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@DisallowConcurrentExecution
+@Component
+@PersistJobDataAfterExecution
+@Setter
+public class PaginatorCleanupJob extends QuartzJobBean {
+
+    private String paginatorId;
+    private String accessorId;
+
+    @Autowired
+    private PaginatorServiceBean paginatorServiceBean;
+
+    @Autowired
+    private MessageService messageService;
+
+    @Autowired
+    private ComponentPayloadManagementService componentPayloadManagementService;
+
+    @Override
+    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+        PaginatorServiceBean.PaginatorInfo info = paginatorServiceBean.getPaginatorInfo(paginatorId);
+        log.info("Executing paginator cleanup for paginator {}", paginatorId);
+        if(info != null && info.getLastAccessor().equals(accessorId)) {
+            log.info("Last accessor was {} - which was the start of this job - deleting", info.getLastAccessor());
+            paginatorServiceBean.cleanupPaginator(info);
+        } else {
+            log.info("The last accessor did either not start this job, or there was no configuration found.");
+        }
+    }
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/listener/PaginatorButtonListener.java

@@ -0,0 +1,97 @@
+package dev.sheldan.abstracto.core.listener;
+
+import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.listener.async.jda.ButtonClickedListener;
+import dev.sheldan.abstracto.core.model.PaginatorButtonPayload;
+import dev.sheldan.abstracto.core.models.listener.ButtonClickedListenerModel;
+import dev.sheldan.abstracto.core.service.MessageService;
+import dev.sheldan.abstracto.core.service.PaginatorServiceBean;
+import dev.sheldan.abstracto.core.templating.model.EmbedConfiguration;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.templating.service.TemplateServiceBean;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.UUID;
+
+
+@Component
+@Slf4j
+public class PaginatorButtonListener implements ButtonClickedListener {
+
+    @Autowired
+    private PaginatorServiceBean paginatorServiceBean;
+
+    @Autowired
+    private MessageService messageService;
+
+    @Autowired
+    private TemplateServiceBean templateServiceBean;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Override
+    public ButtonClickedListenerResult execute(ButtonClickedListenerModel model) {
+        PaginatorButtonPayload payload = (PaginatorButtonPayload) model.getDeserializedPayload();
+
+        Message originalMessage = model.getEvent().getMessage();
+        if(originalMessage == null) {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+        if(payload.getAllowedUser() != null && model.getEvent().getUser().getIdLong() != payload.getAllowedUser()) {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+        String buttonId = model.getEvent().getComponentId();
+        if(buttonId.equals(payload.getExitButtonId())) {
+            log.info("Deleting paginator {} because of exit button {}.", payload.getPaginatorId(), buttonId);
+            originalMessage.delete().queue();
+            paginatorServiceBean.cleanupPaginatorPayloads(payload);
+            return ButtonClickedListenerResult.ACKNOWLEDGED;
+        }
+        if(payload.getSinglePage()) {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+        int targetPage;
+        if(buttonId.equals(payload.getStartButtonId())) {
+            targetPage = 0;
+        } else if(buttonId.equals(payload.getPreviousButtonId())) {
+            targetPage = Math.max(paginatorServiceBean.getCurrentPage(payload.getPaginatorId()) - 1, 0);
+        } else if(buttonId.equals(payload.getNextButtonId())) {
+            targetPage = Math.min(paginatorServiceBean.getCurrentPage(payload.getPaginatorId()) + 1, payload.getEmbedConfigs().size() - 1);
+        } else if(buttonId.equals(payload.getLastButtonId())) {
+            targetPage = payload.getEmbedConfigs().size() - 1;
+        } else {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+        log.debug("Moving to page {} in paginator {}.", targetPage, payload.getPaginatorId());
+        EmbedConfiguration embedConfiguration = payload.getEmbedConfigs().get(targetPage);
+        MessageToSend messageToSend = templateServiceBean.convertEmbedConfigurationToMessageToSend(embedConfiguration);
+        messageService.editMessageInChannel(model.getEvent().getMessageChannel(), messageToSend, originalMessage.getIdLong())
+                .thenAccept(unused -> log.info("Updated paginator {} to switch to page {}.", payload.getPaginatorId(), targetPage));
+        String accessorId = UUID.randomUUID().toString();
+        paginatorServiceBean.updateCurrentPage(payload.getPaginatorId(), targetPage, accessorId);
+        paginatorServiceBean.schedulePaginationDeletion(payload.getPaginatorId(), accessorId);
+        return ButtonClickedListenerResult.ACKNOWLEDGED;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.HIGH;
+    }
+
+    @Override
+    public Boolean handlesEvent(ButtonClickedListenerModel model) {
+        return PaginatorServiceBean.PAGINATOR_BUTTON.equals(model.getOrigin());
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return CoreFeatureDefinition.CORE_FEATURE;
+    }
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/model/PaginatorButtonPayload.java

@@ -0,0 +1,24 @@
+package dev.sheldan.abstracto.core.model;
+
+import dev.sheldan.abstracto.core.models.template.button.ButtonPayload;
+import dev.sheldan.abstracto.core.templating.model.EmbedConfiguration;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class PaginatorButtonPayload implements ButtonPayload {
+    private List<EmbedConfiguration> embedConfigs;
+    private String paginatorId;
+    private String exitButtonId;
+    private String startButtonId;
+    private String previousButtonId;
+    private String nextButtonId;
+    private String lastButtonId;
+    private Boolean singlePage;
+    private Long allowedUser;
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/model/PaginatorConfiguration.java

@@ -1,5 +1,7 @@
 package dev.sheldan.abstracto.core.model;
 
+import dev.sheldan.abstracto.core.models.template.button.ButtonConfigModel;
+import dev.sheldan.abstracto.core.templating.model.EmbedConfiguration;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
@@ -10,9 +12,14 @@ import java.util.List;
 @Setter
 @Builder
 public class PaginatorConfiguration {
-    private String headerText;
-    private List<String> items;
+    private List<EmbedConfiguration> embedConfigs;
+    private String paginatorId;
     private Long timeoutSeconds;
-    private Boolean showPageNumbers;
-    private Boolean useNumberedItems;
+    private Boolean restrictUser;
+    private ButtonConfigModel exitButton;
+    private ButtonConfigModel startButton;
+    private ButtonConfigModel previousButton;
+    private ButtonConfigModel nextButton;
+    private ButtonConfigModel lastButton;
+    private Boolean singlePage;
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/model/PaginatorFooterModel.java

@@ -0,0 +1,13 @@
+package dev.sheldan.abstracto.core.model;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Builder
+public class PaginatorFooterModel {
+    private Integer page;
+    private Integer pageCount;
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/model/PaginatorModel.java

@@ -0,0 +1,17 @@
+package dev.sheldan.abstracto.core.model;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Builder
+public class PaginatorModel {
+    private Object innerModel;
+    private String exitButtonId;
+    private String startButtonId;
+    private String previousButtonId;
+    private String nextButtonId;
+    private String lastButtonId;
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ChannelServiceBean.java

@@ -307,6 +307,7 @@ public class ChannelServiceBean implements ChannelService {
         if(messageToSend.getReferencedMessageId() != null) {
             messageAction = messageAction.referenceById(messageToSend.getReferencedMessageId());
         }
+        messageAction = messageAction.setActionRows(messageToSend.getActionRows());
         metricService.incrementCounter(MESSAGE_EDIT_METRIC);
         return messageAction.submit();
     }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/MessageServiceBean.java

@@ -191,6 +191,11 @@ public class MessageServiceBean implements MessageService {
         return openPrivateChannelForUser(user).thenCompose(privateChannel -> channelService.editMessageInAChannelFuture(messageToSend, privateChannel, messageId).thenApply(message -> null));
     }
 
+    @Override
+    public CompletableFuture<Void> editMessageInChannel(MessageChannel channel, MessageToSend messageToSend, Long messageId) {
+        return channelService.editMessageInAChannelFuture(messageToSend, channel, messageId).thenApply(message -> null);
+    }
+
     @Override
     public CompletableFuture<Message> loadMessageFromCachedMessage(CachedMessage cachedMessage) {
         return loadMessage(cachedMessage.getServerId(), cachedMessage.getChannelId(), cachedMessage.getMessageId());

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/PaginatorServiceBean.java

@@ -1,19 +1,39 @@
 package dev.sheldan.abstracto.core.service;
 
 import com.google.gson.Gson;
-import com.jagrosh.jdautilities.commons.waiter.EventWaiter;
-import com.jagrosh.jdautilities.menu.Paginator;
+import dev.sheldan.abstracto.core.model.PaginatorButtonPayload;
 import dev.sheldan.abstracto.core.model.PaginatorConfiguration;
+import dev.sheldan.abstracto.core.model.PaginatorFooterModel;
+import dev.sheldan.abstracto.core.model.PaginatorModel;
+import dev.sheldan.abstracto.core.models.template.button.ButtonConfigModel;
+import dev.sheldan.abstracto.core.service.management.ComponentPayloadManagementService;
+import dev.sheldan.abstracto.core.templating.model.EmbedConfiguration;
+import dev.sheldan.abstracto.core.templating.model.EmbedFooter;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
-import net.dv8tion.jda.api.entities.MessageEmbed;
-import org.apache.commons.lang3.ObjectUtils;
+import dev.sheldan.abstracto.core.templating.service.TemplateServiceBean;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.scheduling.model.JobParameters;
+import dev.sheldan.abstracto.scheduling.service.SchedulerService;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.TextChannel;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
-import java.util.concurrent.TimeUnit;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReentrantLock;
 
 @Component
+@Slf4j
 public class PaginatorServiceBean implements PaginatorService {
 
     @Autowired
@@ -28,42 +48,224 @@ public class PaginatorServiceBean implements PaginatorService {
     @Autowired
     private MessageService messageService;
 
-    @Override
-    public Paginator createPaginatorFromTemplate(String templateKey, Object model, EventWaiter waiter, Long server) {
-        String embedConfig = templateService.renderTemplate(templateKey + "_paginator", model);
-        PaginatorConfiguration configuration = gson.fromJson(embedConfig, PaginatorConfiguration.class);
-        List<String> items = configuration.getItems();
-        int itemsPerPage = findAppropriateCountPerPage(items);
+    @Autowired
+    private ComponentService componentService;
 
-        return new Paginator.Builder()
-                .setItemsPerPage(itemsPerPage)
-                .setText(configuration.getHeaderText())
-                .showPageNumbers(ObjectUtils.defaultIfNull(configuration.getShowPageNumbers(), false))
-                .setItems(configuration.getItems().toArray(new String[0]))
-                .useNumberedItems(ObjectUtils.defaultIfNull(configuration.getUseNumberedItems(), false))
-                .setEventWaiter(waiter)
-                .waitOnSinglePage(true)
-                .setTimeout(ObjectUtils.defaultIfNull(configuration.getTimeoutSeconds(), 120L), TimeUnit.SECONDS)
-                .setFinalAction(message -> messageService.deleteMessage(message))
+    @Autowired
+    private ComponentPayloadManagementService componentPayloadManagementService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Autowired
+    private PaginatorServiceBean self;
+
+    @Autowired
+    private TemplateServiceBean templateServiceBean;
+
+    @Autowired
+    private SchedulerService schedulerService;
+
+    private static final Map<String, PaginatorInfo> PAGINATORS = new ConcurrentHashMap<>();
+    public static final String PAGINATOR_BUTTON = "PAGINATOR_BUTTON";
+    public static final String PAGINATOR_FOOTER_TEMPLATE_KEY = "paginator_footer";
+    private static final ReentrantLock lock = new ReentrantLock();
+
+    @Override
+    public CompletableFuture<Void> createPaginatorFromTemplate(String templateKey, Object model, TextChannel textChannel, Long userId) {
+        Long serverId = textChannel.getGuild().getIdLong();
+        String exitButtonId = componentService.generateComponentId(serverId);
+        String startButtonId = componentService.generateComponentId(serverId);
+        String previousButtonId = componentService.generateComponentId(serverId);
+        String nextButtonId = componentService.generateComponentId(serverId);
+        String lastButtonId = componentService.generateComponentId(serverId);
+        PaginatorModel wrapperModel = PaginatorModel
+                .builder()
+                .exitButtonId(exitButtonId)
+                .startButtonId(startButtonId)
+                .previousButtonId(previousButtonId)
+                .nextButtonId(nextButtonId)
+                .lastButtonId(lastButtonId)
+                .innerModel(model)
+                .build();
+        String embedConfig = templateService.renderTemplate(templateKey + "_paginator", wrapperModel, serverId);
+        PaginatorConfiguration configuration = gson.fromJson(embedConfig, PaginatorConfiguration.class);
+        log.info("Setting up paginator in channel {} in server {} with {} pages.", textChannel.getIdLong(),
+                textChannel.getGuild().getIdLong(), configuration.getEmbedConfigs().size());
+        setupFooters(configuration);
+
+        configuration.setPaginatorId(componentService.generateComponentId());
+        configuration.setSinglePage(configuration.getEmbedConfigs().size() < 2);
+        PaginatorButtonPayload buttonPayload = getButtonPayload(configuration, exitButtonId, startButtonId, previousButtonId, nextButtonId, lastButtonId);
+        if(configuration.getRestrictUser() != null && configuration.getRestrictUser()) {
+            buttonPayload.setAllowedUser(userId);
+        }
+        configuration.setExitButton(initializeButton(exitButtonId, buttonPayload));
+        if(!configuration.getSinglePage()) {
+            log.debug("Adding additional buttons for pagination to paginator {}.", configuration.getPaginatorId());
+            configuration.setStartButton(initializeButton(startButtonId, buttonPayload));
+            configuration.setPreviousButton(initializeButton(previousButtonId, buttonPayload));
+            configuration.setNextButton(initializeButton(nextButtonId, buttonPayload));
+            configuration.setLastButton(initializeButton(lastButtonId, buttonPayload));
+        }
+
+        EmbedConfiguration embedConfiguration = configuration.getEmbedConfigs().get(0);
+        MessageToSend messageToSend = templateServiceBean.convertEmbedConfigurationToMessageToSend(embedConfiguration);
+        List<CompletableFuture<Message>> paginatorFutures = channelService.sendMessageToSendToChannel(messageToSend, textChannel);
+        return FutureUtils.toSingleFutureGeneric(paginatorFutures)
+                .thenAccept(unused -> self.setupButtonPayloads(paginatorFutures.get(0).join(), configuration, serverId, buttonPayload));
+    }
+
+    private void setupFooters(PaginatorConfiguration configuration) {
+        for (int i = 0; i < configuration.getEmbedConfigs().size(); i++) {
+            PaginatorFooterModel paginatorModel = PaginatorFooterModel
+                    .builder()
+                    .page(i + 1)
+                    .pageCount(configuration.getEmbedConfigs().size())
+                    .build();
+            String footerText = templateService.renderTemplate(PAGINATOR_FOOTER_TEMPLATE_KEY, paginatorModel);
+            EmbedConfiguration embedConfiguration = configuration.getEmbedConfigs().get(i);
+            if(embedConfiguration.getFooter() == null) {
+                embedConfiguration.setFooter(EmbedFooter.builder().text(footerText).build());
+            } else {
+                embedConfiguration.getFooter().setText(footerText);
+            }
+        }
+    }
+
+    public void cleanupPaginatorPayloads(PaginatorButtonPayload configuration) {
+        List<String> payloadIds = getAllPayloadIdsFromPayload(configuration);
+        componentPayloadManagementService.deletePayloads(payloadIds);
+    }
+
+    private List<String> getAllPayloadIdsFromPayload(PaginatorButtonPayload configuration) {
+        List<String> payloadIds = new ArrayList<>(Arrays.asList(configuration.getExitButtonId()));
+        if(!configuration.getSinglePage()) {
+            payloadIds.add(configuration.getStartButtonId());
+            payloadIds.add(configuration.getPreviousButtonId());
+            payloadIds.add(configuration.getNextButtonId());
+            payloadIds.add(configuration.getLastButtonId());
+        }
+        return payloadIds;
+    }
+
+
+    private ButtonConfigModel initializeButton(String buttonId, PaginatorButtonPayload paginatorButtonPayload) {
+        return ButtonConfigModel
+                .builder()
+                .buttonId(buttonId)
+                .buttonPayload(paginatorButtonPayload)
+                .payloadType(PaginatorButtonPayload.class)
+                .origin(PAGINATOR_BUTTON)
                 .build();
     }
 
-    private int findAppropriateCountPerPage(List<String> items) {
-        int currentMin = Integer.MAX_VALUE;
-        // to be sure, because the paginator adds some characters here and there
-        int carefulMax = MessageEmbed.TEXT_MAX_LENGTH - 50;
-        for (int i = 0; i < items.size(); i++) {
-            int count = 0;
-            int length = 0;
-            for (String innerItem : items) {
-                length += innerItem.length();
-                if (length > carefulMax) {
-                    currentMin = Math.min(currentMin, count);
-                    break;
-                }
-                count++;
-            }
-        }
-        return currentMin;
+    private PaginatorButtonPayload getButtonPayload(PaginatorConfiguration configuration, String exitButtonId,
+                                                    String startButtonId, String previousButtonId,
+                                                    String nextButtonId, String lastButtonId) {
+        return PaginatorButtonPayload
+                .builder()
+                .paginatorId(configuration.getPaginatorId())
+                .exitButtonId(exitButtonId)
+                .startButtonId(startButtonId)
+                .previousButtonId(previousButtonId)
+                .nextButtonId(nextButtonId)
+                .lastButtonId(lastButtonId)
+                .embedConfigs(configuration.getEmbedConfigs())
+                .singlePage(configuration.getSinglePage())
+                .build();
     }
+
+    public Integer getCurrentPage(String paginatorId) {
+        return PAGINATORS.get(paginatorId).currentPage;
+    }
+
+    public PaginatorInfo getPaginatorInfo(String paginatorId) {
+        return PAGINATORS.get(paginatorId);
+    }
+
+    public void updateCurrentPage(String paginatorId, Integer newPage, String newAccessorId) {
+        try {
+            lock.lock();
+            PaginatorInfo paginatorInfo = PAGINATORS.get(paginatorId);
+            if(paginatorInfo != null) {
+                paginatorInfo.setCurrentPage(newPage);
+                paginatorInfo.setLastAccessor(newAccessorId);
+            }
+        } catch (Exception exception) {
+            lock.unlock();
+            log.error("Failed to update current page for paginator {} to page {}", paginatorId, newPage, exception);
+        }
+    }
+
+    public void schedulePaginationDeletion(String paginatorId, String accessorId) {
+        PaginatorServiceBean.PaginatorInfo paginatorInfo = PAGINATORS.get(paginatorId);
+        HashMap<Object, Object> parameters = new HashMap<>();
+        parameters.put("paginatorId", paginatorId);
+        parameters.put("accessorId", accessorId);
+        JobParameters jobParameters = JobParameters
+                .builder()
+                .parameters(parameters)
+                .build();
+        Instant targetDate = Instant.now().plus(paginatorInfo.getTimeoutSeconds(), ChronoUnit.SECONDS);
+        schedulerService.executeJobWithParametersOnce("paginatorCleanupJob", "core", jobParameters, Date.from(targetDate));
+        log.debug("Scheduled job to delete the paginator {} in {} seconds.", paginatorId, paginatorInfo.getTimeoutSeconds());
+    }
+
+    @Transactional
+    public void setupButtonPayloads(Message paginatorMessage, PaginatorConfiguration configuration, Long serverId, PaginatorButtonPayload payload) {
+        savePayload(configuration.getExitButton(), serverId);
+        if(!configuration.getSinglePage()) {
+            savePayload(configuration.getStartButton(), serverId);
+            savePayload(configuration.getPreviousButton(), serverId);
+            savePayload(configuration.getNextButton(), serverId);
+            savePayload(configuration.getLastButton(), serverId);
+        }
+
+        String accessorId = UUID.randomUUID().toString();
+
+        PaginatorInfo info = PaginatorInfo
+                .builder()
+                .currentPage(0)
+                .serverId(serverId)
+                .channelId(paginatorMessage.getChannel().getIdLong())
+                .messageId(paginatorMessage.getIdLong())
+                .timeoutSeconds(configuration.getTimeoutSeconds())
+                .paginatorId(configuration.getPaginatorId())
+                .payloadIds(getAllPayloadIdsFromPayload(payload))
+                .lastAccessor(accessorId)
+                .build();
+        log.debug("We are using the accessor id {} for paginator {} initially.", accessorId, configuration.getPaginatorId());
+        PAGINATORS.put(configuration.getPaginatorId(), info);
+
+        schedulePaginationDeletion(configuration.getPaginatorId(), accessorId);
+    }
+
+    private void savePayload(ButtonConfigModel model, Long serverId) {
+        componentPayloadManagementService.createPayload(model, serverId);
+    }
+
+    @Transactional
+    public void cleanupPaginator(PaginatorInfo paginatorInfo) {
+        log.info("Cleaning up paginator {} in server {} channel {} message {}.", paginatorInfo.getPaginatorId(),
+                paginatorInfo.getServerId(), paginatorInfo.getChannelId(), paginatorInfo.getMessageId());
+        messageService.deleteMessageInChannelInServer(paginatorInfo.getServerId(), paginatorInfo.getChannelId(), paginatorInfo.getMessageId());
+        componentPayloadManagementService.deletePayloads(paginatorInfo.getPayloadIds());
+    }
+
+    @Getter
+    @Builder
+    public static class PaginatorInfo {
+        @Setter
+        private Integer currentPage;
+        private Long serverId;
+        private Long channelId;
+        private Long messageId;
+        private String paginatorId;
+        @Setter
+        private String lastAccessor;
+        private Long timeoutSeconds;
+        private List<String> payloadIds;
+    }
+
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/ComponentPayloadManagementServiceBean.java

@@ -23,6 +23,9 @@ public class ComponentPayloadManagementServiceBean implements ComponentPayloadMa
     @Autowired
     private Gson gson;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public ComponentPayload createPayload(String id, String payload, Class payloadType, String buttonOrigin, AServer server, ComponentType componentType) {
         ComponentPayload componentPayload = ComponentPayload
@@ -43,6 +46,12 @@ public class ComponentPayloadManagementServiceBean implements ComponentPayloadMa
         return createPayload(buttonConfigModel.getButtonId(), payload, buttonConfigModel.getPayloadType(), buttonConfigModel.getOrigin(), server, ComponentType.BUTTON);
     }
 
+    @Override
+    public ComponentPayload createPayload(ButtonConfigModel buttonConfigModel, Long serverId) {
+        AServer server = serverManagementService.loadOrCreate(serverId);
+        return createPayload(buttonConfigModel, server);
+    }
+
     @Override
     public Optional<ComponentPayload> findPayload(String id) {
         return repository.findById(id);

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/templating/service/TemplateServiceBean.java

@@ -82,6 +82,10 @@ public class TemplateServiceBean implements TemplateService {
     public MessageToSend renderEmbedTemplate(String key, Object model) {
         String embedConfig = this.renderTemplate(key + "_embed", model);
         EmbedConfiguration embedConfiguration = gson.fromJson(embedConfig, EmbedConfiguration.class);
+        return convertEmbedConfigurationToMessageToSend(embedConfiguration);
+    }
+
+    public MessageToSend convertEmbedConfigurationToMessageToSend(EmbedConfiguration embedConfiguration) {
         List<EmbedBuilder> embedBuilders = new ArrayList<>();
         embedBuilders.add(new EmbedBuilder());
         if(embedConfiguration.getMetaConfig() != null &&

abstracto-application/core/core-impl/src/main/resources/migrations/1.3.10/collection.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd">
+    <include file="seedData/data.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/core/core-impl/src/main/resources/migrations/1.3.10/seedData/data.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <include file="paginatorCleanupJob.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/core/core-impl/src/main/resources/migrations/1.3.10/seedData/paginatorCleanupJob.xml

@@ -0,0 +1,18 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <changeSet author="Sheldan" id="paginator-cleanup-job-insert">
+        <insert tableName="scheduler_job">
+            <column name="name" value="paginatorCleanupJob"/>
+            <column name="group_name" value="core"/>
+            <column name="clazz" value="dev.sheldan.abstracto.core.job.PaginatorCleanupJob"/>
+            <column name="active" value="true"/>
+            <column name="recovery" value="false"/>
+        </insert>
+    </changeSet>
+</databaseChangeLog>

abstracto-application/core/core-impl/src/main/resources/migrations/core-changeLog.xml

@@ -21,4 +21,5 @@
     <include file="1.3.5/collection.xml" relativeToChangelogFile="true"/>
     <include file="1.3.6/collection.xml" relativeToChangelogFile="true"/>
     <include file="1.3.9/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.3.10/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>