#3 session API draft

stbf-api/src/main/java/ru/penkrat/stbf/api/BotRequest.java

@@ -14,4 +14,5 @@ public interface BotRequest {
 
 	Long getChatId();
 
+	BotSession getSession();
 }

stbf-api/src/main/java/ru/penkrat/stbf/api/BotSession.java

@@ -0,0 +1,9 @@
+package ru.penkrat.stbf.api;
+
+public interface BotSession {
+
+    Object getAttribute(String name);
+
+    void setAttribute(String name, Object value);
+
+}

stbf-api/src/main/java/ru/penkrat/stbf/api/SessionProvider.java

@@ -0,0 +1,8 @@
+package ru.penkrat.stbf.api;
+
+@FunctionalInterface
+public interface SessionProvider {
+
+    BotSession get(Long chatId);
+
+}

stbf-common/src/main/java/ru/penkrat/stbf/common/session/InMemBotSessionProvider.java

@@ -0,0 +1,18 @@
+package ru.penkrat.stbf.common.session;
+
+import ru.penkrat.stbf.api.BotSession;
+import ru.penkrat.stbf.api.SessionProvider;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class InMemBotSessionProvider implements SessionProvider {
+
+    private static final Map<Long, BotSession> MAP = new ConcurrentHashMap<>();
+
+    @Override
+    public BotSession get(Long chatId) {
+        return MAP.computeIfAbsent(chatId, k -> new MapBackedBotSession(new ConcurrentHashMap<>()));
+    }
+
+}

stbf-common/src/main/java/ru/penkrat/stbf/common/session/MapBackedBotSession.java

@@ -0,0 +1,22 @@
+package ru.penkrat.stbf.common.session;
+
+import lombok.RequiredArgsConstructor;
+import ru.penkrat.stbf.api.BotSession;
+
+import java.util.Map;
+
+@RequiredArgsConstructor
+class MapBackedBotSession implements BotSession {
+
+    private final Map<String, Object> map;
+
+    @Override
+    public Object getAttribute(String name) {
+        return map.get(name);
+    }
+
+    @Override
+    public void setAttribute(String name, Object value) {
+        map.put(name, value);
+    }
+}

stbf-demo/pom.xml

@@ -34,6 +34,11 @@
             <groupId>ru.penkrat.stbf</groupId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <artifactId>stbf-common</artifactId>
+            <groupId>ru.penkrat.stbf</groupId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>info.picocli</groupId>
             <artifactId>picocli</artifactId>

stbf-demo/src/main/java/ru/penkrat/stbf/demo/App.java

@@ -5,6 +5,7 @@ import org.slf4j.LoggerFactory;
 import picocli.CommandLine;
 import ru.penkrat.stbf.api.BotCommandChain;
 import ru.penkrat.stbf.api.CommandChain;
+import ru.penkrat.stbf.common.session.InMemBotSessionProvider;
 import ru.penkrat.stbf.impl.pengrad.PengradTelegramBot;
 import ru.penkrat.stbf.templates.xml.XmlFlowResolver;
 
@@ -38,7 +39,7 @@ public class App implements Runnable {
     }
 
     private Runnable start(String token, CommandChain chain) {
-        return () -> botAtomicReference.set(new PengradTelegramBot(token, chain));
+        return () -> botAtomicReference.set(new PengradTelegramBot(token, chain, new InMemBotSessionProvider()));
     }
 
     private void onShutdown() {

stbf-pengrad/src/main/java/ru/penkrat/stbf/impl/pengrad/BotRequestImpl.java

@@ -1,61 +1,64 @@
 package ru.penkrat.stbf.impl.pengrad;
 
-import static lombok.AccessLevel.PROTECTED;
-
-import java.util.Optional;
-
 import com.pengrad.telegrambot.model.CallbackQuery;
 import com.pengrad.telegrambot.model.Contact;
 import com.pengrad.telegrambot.model.Message;
 import com.pengrad.telegrambot.model.Update;
-
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import ru.penkrat.stbf.api.BotRequest;
+import ru.penkrat.stbf.api.BotSession;
+
+import java.util.Optional;
+
+import static lombok.AccessLevel.PROTECTED;
 
 @RequiredArgsConstructor
 public class BotRequestImpl implements BotRequest {
 
-	@Getter(PROTECTED)
+    @Getter(PROTECTED)
-	private final Update update;
+    private final Update update;
 
-	@Override
+    @Getter
-	public Optional<String> getMessageText() {
+    private final BotSession session;
-		if (update.message() != null) {
-			return Optional.ofNullable(update.message().text());
-		}
-		return Optional.empty();
-	}
 
-	@Override
+    @Override
-	public Optional<String> getPhoneNumber() {
+    public Optional<String> getMessageText() {
-		return Optional.of(update)
+        if (update.message() != null) {
-				.map(Update::message)
+            return Optional.ofNullable(update.message().text());
-				.map(Message::contact)
+        }
-				.map(Contact::phoneNumber);
+        return Optional.empty();
-	}
+    }
 
-	@Override
+    @Override
-	public Optional<String> getCallbackData() {
+    public Optional<String> getPhoneNumber() {
-		return Optional.of(update)
+        return Optional.of(update)
-				.map(Update::callbackQuery)
+                .map(Update::message)
-				.map(CallbackQuery::data);
+                .map(Message::contact)
-	}
+                .map(Contact::phoneNumber);
+    }
 
-	@Override
+    @Override
-	public Optional<String> getCallbackMessageText() {
+    public Optional<String> getCallbackData() {
-		return Optional.of(update)
+        return Optional.of(update)
-				.map(Update::callbackQuery)
+                .map(Update::callbackQuery)
-				.map(CallbackQuery::message)
+                .map(CallbackQuery::data);
-				.map(Message::text);
+    }
-	}
 
-	@Override
+    @Override
-	public Long getChatId() {
+    public Optional<String> getCallbackMessageText() {
-		return Optional.of(update)
+        return Optional.of(update)
-				.map(Update::callbackQuery)
+                .map(Update::callbackQuery)
-				.map(CallbackQuery::message)
+                .map(CallbackQuery::message)
-				.orElseGet(() -> update.message()).chat().id();
+                .map(Message::text);
-	}
+    }
+
+    @Override
+    public Long getChatId() {
+        return Optional.of(update)
+                .map(Update::callbackQuery)
+                .map(CallbackQuery::message)
+                .orElseGet(() -> update.message()).chat().id();
+    }
 
 }

stbf-pengrad/src/main/java/ru/penkrat/stbf/impl/pengrad/PengradTelegramBot.java

@@ -2,34 +2,48 @@ package ru.penkrat.stbf.impl.pengrad;
 
 import com.pengrad.telegrambot.TelegramBot;
 import com.pengrad.telegrambot.UpdatesListener;
+import com.pengrad.telegrambot.model.CallbackQuery;
 import com.pengrad.telegrambot.model.Update;
-
 import lombok.extern.slf4j.Slf4j;
 import ru.penkrat.stbf.api.CommandChain;
+import ru.penkrat.stbf.api.SessionProvider;
+
+import java.util.Optional;
 
 @Slf4j
 public class PengradTelegramBot extends TelegramBot implements AutoCloseable {
 
-	public PengradTelegramBot(String botToken, CommandChain commandChain) {
+    public PengradTelegramBot(String botToken, CommandChain commandChain) {
-		super(botToken);
+        this(botToken, commandChain, (id) -> {
-		this.setUpdatesListener(updates -> {
+            throw new IllegalArgumentException("'SessionProvider' is not defined");
-			for (Update update : updates) {
+        });
-				try {
+    }
-					commandChain.processCommand(
-							new BotRequestImpl(update),
-							new BotResponseImpl(update, this));
-				} catch (Exception e) {
-					log.error("Bot Error:", e);
-				}
-			}
-			return UpdatesListener.CONFIRMED_UPDATES_ALL;
-		});
-	}
 
-	@Override
+    public PengradTelegramBot(String botToken, CommandChain commandChain, SessionProvider sessionProvider) {
-	public void close() throws Exception {
+        super(botToken);
-		removeGetUpdatesListener();
+        this.setUpdatesListener(updates -> {
-		log.debug("Bot closed.");
+            for (Update update : updates) {
-	}
+                try {
+                    final Long chatId = Optional.of(update)
+                            .map(Update::callbackQuery)
+                            .map(CallbackQuery::message)
+                            .orElseGet(() -> update.message()).chat().id();
+
+                    commandChain.processCommand(
+                            new BotRequestImpl(update, sessionProvider.get(chatId)),
+                            new BotResponseImpl(update, this));
+                } catch (Exception e) {
+                    log.error("Bot Error:", e);
+                }
+            }
+            return UpdatesListener.CONFIRMED_UPDATES_ALL;
+        });
+    }
+
+    @Override
+    public void close() throws Exception {
+        removeGetUpdatesListener();
+        log.debug("Bot closed.");
+    }
 
 }

stbf-rubenlagus/src/main/java/ru/penkrat/stbf/impl/rubenlagus/BotRequestImpl.java

@@ -1,58 +1,61 @@
 package ru.penkrat.stbf.impl.rubenlagus;
 
-import static lombok.AccessLevel.PROTECTED;
+import lombok.Getter;
-
+import lombok.RequiredArgsConstructor;
-import java.util.Optional;
-
 import org.telegram.telegrambots.meta.api.objects.CallbackQuery;
 import org.telegram.telegrambots.meta.api.objects.Contact;
 import org.telegram.telegrambots.meta.api.objects.Message;
 import org.telegram.telegrambots.meta.api.objects.Update;
-
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
 import ru.penkrat.stbf.api.BotRequest;
+import ru.penkrat.stbf.api.BotSession;
+
+import java.util.Optional;
+
+import static lombok.AccessLevel.PROTECTED;
 
 @RequiredArgsConstructor
 class BotRequestImpl implements BotRequest {
 
-	@Getter(PROTECTED)
+    @Getter(PROTECTED)
-	private final Update update;
+    private final Update update;
 
-	@Override
+    @Getter
-	public Optional<String> getMessageText() {
+    private final BotSession session;
-		if (update.hasMessage()) {
-			return Optional.ofNullable(update.getMessage().getText());
-		}
-		return Optional.empty();
-	}
 
-	@Override
+    @Override
-	public Optional<String> getPhoneNumber() {
+    public Optional<String> getMessageText() {
-		return Optional.of(update)
+        if (update.hasMessage()) {
-				.map(Update::getMessage)
+            return Optional.ofNullable(update.getMessage().getText());
-				.map(Message::getContact)
+        }
-				.map(Contact::getPhoneNumber);
+        return Optional.empty();
-	}
+    }
 
-	@Override
+    @Override
-	public Optional<String> getCallbackData() {
+    public Optional<String> getPhoneNumber() {
-		return Optional.of(update)
+        return Optional.of(update)
-				.map(Update::getCallbackQuery)
+                .map(Update::getMessage)
-				.map(CallbackQuery::getData);
+                .map(Message::getContact)
-	}
+                .map(Contact::getPhoneNumber);
+    }
 
-	@Override
+    @Override
-	public Optional<String> getCallbackMessageText() {
+    public Optional<String> getCallbackData() {
-		return Optional.of(update)
+        return Optional.of(update)
-				.map(Update::getCallbackQuery)
+                .map(Update::getCallbackQuery)
-				.map(CallbackQuery::getMessage)
+                .map(CallbackQuery::getData);
-				.map(Message::getText);
+    }
-	}
 
-	@Override
+    @Override
-	public Long getChatId() {
+    public Optional<String> getCallbackMessageText() {
-		return update.getMessage().getChatId();
+        return Optional.of(update)
-	}
+                .map(Update::getCallbackQuery)
+                .map(CallbackQuery::getMessage)
+                .map(Message::getText);
+    }
+
+    @Override
+    public Long getChatId() {
+        return Utils.getChatId(update);
+    }
 
 }

stbf-rubenlagus/src/main/java/ru/penkrat/stbf/impl/rubenlagus/RubenlagusTelegramBot.java

@@ -1,54 +1,62 @@
 package ru.penkrat.stbf.impl.rubenlagus;
 
+import lombok.extern.slf4j.Slf4j;
 import org.telegram.telegrambots.bots.TelegramLongPollingBot;
 import org.telegram.telegrambots.meta.TelegramBotsApi;
 import org.telegram.telegrambots.meta.api.objects.Update;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
-
-import lombok.extern.slf4j.Slf4j;
 import ru.penkrat.stbf.api.BotCommandChain;
+import ru.penkrat.stbf.api.SessionProvider;
 
 @Slf4j
 public class RubenlagusTelegramBot extends TelegramLongPollingBot {
 
-	private final String botUsername;
+    private final String botUsername;
-	private final String botToken;
+    private final String botToken;
-	private final BotCommandChain commandChain;
+    private final BotCommandChain commandChain;
+    private final SessionProvider sessionProvider;
 
-	public RubenlagusTelegramBot(String botUsername, String botToken, BotCommandChain botCommandChain) {
+    public RubenlagusTelegramBot(String botUsername, String botToken, BotCommandChain botCommandChain) {
-		this.botUsername = botUsername;
+        this(botUsername, botToken, botCommandChain, (id) -> {
-		this.botToken = botToken;
+            throw new IllegalArgumentException("'SessionProvider' is not defined");
-		this.commandChain = botCommandChain;
+        });
+    }
 
-		TelegramBotsApi telegramBotsApi;
+    public RubenlagusTelegramBot(String botUsername, String botToken, BotCommandChain botCommandChain, SessionProvider sessionProvider) {
-		try {
+        this.botUsername = botUsername;
-			telegramBotsApi = new TelegramBotsApi(DefaultBotSession.class);
+        this.botToken = botToken;
-			telegramBotsApi.registerBot(this);
+        this.commandChain = botCommandChain;
-		} catch (TelegramApiException e) {
+        this.sessionProvider = sessionProvider;
-			log.error("Error", e);
-		}
-	}
 
-	@Override
+        TelegramBotsApi telegramBotsApi;
-	public void onUpdateReceived(Update update) {
+        try {
-		try {
+            telegramBotsApi = new TelegramBotsApi(DefaultBotSession.class);
-			commandChain.processCommand(
+            telegramBotsApi.registerBot(this);
-					new BotRequestImpl(update),
+        } catch (TelegramApiException e) {
-					new BotResponseImpl(update, this));
+            log.error("Error", e);
-		} catch (Exception e) {
+        }
-			log.error("Bot Error:", e);
+    }
-		}
-	}
 
-	@Override
+    @Override
-	public String getBotUsername() {
+    public void onUpdateReceived(Update update) {
-		return botUsername;
+        try {
-	}
+            commandChain.processCommand(
+                    new BotRequestImpl(update, sessionProvider.get(Utils.getChatId(update))),
+                    new BotResponseImpl(update, this));
+        } catch (Exception e) {
+            log.error("Bot Error:", e);
+        }
+    }
 
-	@Override
+    @Override
-	public String getBotToken() {
+    public String getBotUsername() {
-		return botToken;
+        return botUsername;
-	}
+    }
+
+    @Override
+    public String getBotToken() {
+        return botToken;
+    }
 
 }

stbf-rubenlagus/src/main/java/ru/penkrat/stbf/impl/rubenlagus/Utils.java

@@ -0,0 +1,21 @@
+package ru.penkrat.stbf.impl.rubenlagus;
+
+import lombok.experimental.UtilityClass;
+import org.telegram.telegrambots.meta.api.objects.Update;
+
+@UtilityClass
+class Utils {
+
+    Long getChatId(Update update) {
+        if (update.getMessage() != null) {
+            return update.getMessage().getChatId();
+        }
+
+        if (update.getCallbackQuery() != null) {
+            update.getCallbackQuery().getMessage().getChatId();
+        }
+
+        throw new IllegalStateException("Can't extract chatId from 'Update'");
+    }
+
+}

stbf-test/src/main/java/ru/penkrat/stbf/test/BotRequestImpl.java

@@ -6,6 +6,7 @@ import java.util.Random;
 import lombok.Builder;
 import lombok.Getter;
 import ru.penkrat.stbf.api.BotRequest;
+import ru.penkrat.stbf.api.BotSession;
 
 @Builder
 class BotRequestImpl implements BotRequest {
@@ -14,6 +15,7 @@ class BotRequestImpl implements BotRequest {
 	private String phoneNumber;
 	private String callbackData;
 	private String callbackMessageText;
+	private BotSession session;
 
 	@Getter
 	@Builder.Default
@@ -39,4 +41,9 @@ class BotRequestImpl implements BotRequest {
 		return Optional.ofNullable(callbackMessageText);
 	}
 
+	@Override
+	public BotSession getSession() {
+		return session;
+	}
+
 }