├── .gitignore
├── README.md
├── pom.xml
├── screenshots
    ├── 1.jpg
    ├── 2.jpg
    ├── 3.jpg
    ├── 4.jpg
    ├── 5.jpg
    ├── 6.jpg
    └── 7.jpg
└── src
    └── main
        ├── docker
            ├── Dockerfile
            ├── docker-compose.yml
            ├── variables-bot.env
            └── variables-spring.env
        ├── java
            └── ru
            │   └── booking
            │       └── bot
            │           ├── BookingBot2Application.java
            │           ├── bot
            │               ├── Bot.java
            │               ├── BotService.java
            │               ├── BotServiceImpl.java
            │               ├── Button.java
            │               ├── Runner.java
            │               └── UpdateUtil.java
            │           ├── command
            │               ├── Command.java
            │               ├── CommandContainer.java
            │               ├── CommandName.java
            │               ├── KeyboardMaker.java
            │               └── impl
            │               │   ├── AddObject.java
            │               │   ├── EditObject.java
            │               │   ├── MyBookings.java
            │               │   ├── NewBooking.java
            │               │   └── Start.java
            │           ├── models
            │               ├── Booking.java
            │               ├── BookingObject.java
            │               ├── Type.java
            │               └── User.java
            │           ├── repository
            │               ├── BookingObjectRepository.java
            │               ├── BookingRepository.java
            │               ├── TypeRepository.java
            │               └── UserRepository.java
            │           └── service
            │               ├── BookingObjectService.java
            │               ├── BookingService.java
            │               ├── TypeService.java
            │               └── UserService.java
        └── resources
            └── application.properties


/.gitignore:
--------------------------------------------------------------------------------
1 | *.class
2 | /target
3 | /.idea/
4 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Booking bot
 2 | Телеграм бот для бронирования чего угодно: переговорки, инвентарь, слоты на запись к специалисту и тд.
 3 | 
 4 | Java 17, Spring boot, PostgreSQL
 5 | 
 6 | Реализованы две роли:
 7 | 
 8 | - Пользователь – может забронировать что-то, посмотреть свои брони и отменить.
 9 |  
10 | - Администратор – функционал пользователя, плюс возможность добавлять, редактировать и удалять объекты для бронирования.
11 | 
12 | Команды бота разделены по классам, реализующим общий интерфейс, так что можно легко добавлять новые пользовательские сценарии, не изменяя имеющиеся классы.
13 | 
14 | #### Регистрация нового пользователя. Сохраняется в базу данных вместе с Telegram user id.
15 | 
16 | <img src="https://github.com/EtoMisha/Booking_bot/blob/main/screenshots/1.jpg" height="600" /><br>
17 | 
18 | #### Бронирование
19 | 
20 | <img src="https://github.com/EtoMisha/Booking_bot/blob/main/screenshots/2.jpg" height="600" /> <img src="https://github.com/EtoMisha/Booking_bot/blob/main/screenshots/3.jpg" height="600" /><br>
21 | 
22 | 
23 | #### Добавление объекта в каталог и редактирование прав пользователя (доступно только администратору)
24 | 
25 | <img src="https://github.com/EtoMisha/Booking_bot/blob/main/screenshots/4.jpg" height="600" /> <img src="https://github.com/EtoMisha/Booking_bot/blob/main/screenshots/5.jpg" height="600" /> <img src="https://github.com/EtoMisha/Booking_bot/blob/main/screenshots/6.jpg" height="600" /> 
26 | 
27 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 4 |     <modelVersion>4.0.0</modelVersion>
 5 |     <parent>
 6 |         <groupId>org.springframework.boot</groupId>
 7 |         <artifactId>spring-boot-starter-parent</artifactId>
 8 |         <version>3.1.3</version>
 9 |         <relativePath/> <!-- lookup parent from repository -->
10 |     </parent>
11 |     <groupId>ru.booking</groupId>
12 |     <artifactId>BookingBot</artifactId>
13 |     <version>0.0.1-SNAPSHOT</version>
14 |     <name>BookingBot</name>
15 |     <description>BookingBot</description>
16 |     <properties>
17 |         <java.version>17</java.version>
18 |     </properties>
19 |     <dependencies>
20 |         <dependency>
21 |             <groupId>org.springframework.boot</groupId>
22 |             <artifactId>spring-boot-starter-data-jpa</artifactId>
23 |         </dependency>
24 |         <dependency>
25 |             <groupId>org.postgresql</groupId>
26 |             <artifactId>postgresql</artifactId>
27 |             <scope>runtime</scope>
28 |         </dependency>
29 |         <dependency>
30 |             <groupId>org.projectlombok</groupId>
31 |             <artifactId>lombok</artifactId>
32 |             <optional>true</optional>
33 |         </dependency>
34 |         <dependency>
35 |             <groupId>org.springframework.boot</groupId>
36 |             <artifactId>spring-boot-starter-test</artifactId>
37 |             <scope>test</scope>
38 |         </dependency>
39 |         <dependency>
40 |             <groupId>org.telegram</groupId>
41 |             <artifactId>telegrambots-spring-boot-starter</artifactId>
42 |             <version>5.4.0.1</version>
43 |         </dependency>
44 |     </dependencies>
45 | 
46 |     <build>
47 |         <plugins>
48 |             <plugin>
49 |                 <groupId>org.springframework.boot</groupId>
50 |                 <artifactId>spring-boot-maven-plugin</artifactId>
51 |                 <configuration>
52 |                     <excludes>
53 |                         <exclude>
54 |                             <groupId>org.projectlombok</groupId>
55 |                             <artifactId>lombok</artifactId>
56 |                         </exclude>
57 |                     </excludes>
58 |                 </configuration>
59 |             </plugin>
60 |         </plugins>
61 |     </build>
62 | 
63 | </project>
64 | 


--------------------------------------------------------------------------------
/screenshots/1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EtoMisha/Booking_bot/d25b2d15bacf57bd89651b65ac3f3a0f8a554bc3/screenshots/1.jpg


--------------------------------------------------------------------------------
/screenshots/2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EtoMisha/Booking_bot/d25b2d15bacf57bd89651b65ac3f3a0f8a554bc3/screenshots/2.jpg


--------------------------------------------------------------------------------
/screenshots/3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EtoMisha/Booking_bot/d25b2d15bacf57bd89651b65ac3f3a0f8a554bc3/screenshots/3.jpg


--------------------------------------------------------------------------------
/screenshots/4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EtoMisha/Booking_bot/d25b2d15bacf57bd89651b65ac3f3a0f8a554bc3/screenshots/4.jpg


--------------------------------------------------------------------------------
/screenshots/5.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EtoMisha/Booking_bot/d25b2d15bacf57bd89651b65ac3f3a0f8a554bc3/screenshots/5.jpg


--------------------------------------------------------------------------------
/screenshots/6.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EtoMisha/Booking_bot/d25b2d15bacf57bd89651b65ac3f3a0f8a554bc3/screenshots/6.jpg


--------------------------------------------------------------------------------
/screenshots/7.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EtoMisha/Booking_bot/d25b2d15bacf57bd89651b65ac3f3a0f8a554bc3/screenshots/7.jpg


--------------------------------------------------------------------------------
/src/main/docker/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM amazoncorretto:17
2 | COPY ../../../target/BookingBot-0.0.1-SNAPSHOT.jar booking_bot.jar
3 | EXPOSE 8080
4 | ENTRYPOINT ["java", "-jar", "booking_bot.jar"]


--------------------------------------------------------------------------------
/src/main/docker/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: '3.8'
 2 | 
 3 | services:
 4 |   app:
 5 |     build: .
 6 |     ports:
 7 |       - "8080:8080"
 8 |     depends_on:
 9 |       - db
10 |     env_file:
11 |       - variables-spring.env
12 |       - variables-bot.env
13 |   db:
14 |     image: 'postgres:13.1-alpine'
15 |     environment:
16 |       - POSTGRES_USER=postgres
17 |       - POSTGRES_PASSWORD=postgres
18 |       - POSTGRES_DB=postgres
19 |     ports:
20 |       - "5432:5432"
21 |     volumes:
22 |       - postgres-data:/var/lib/postgresql/data
23 | 
24 | volumes:
25 |   postgres-data:


--------------------------------------------------------------------------------
/src/main/docker/variables-bot.env:
--------------------------------------------------------------------------------
1 | BOT_USERNAME=
2 | BOT_TOKEN=
3 | 
4 | BOT_ADMIN_USERNAME=
5 | BOT_DEFAULT_START_TIME=09.00
6 | BOT_DEFAULT_END_TIME=18.00
7 | BOT_IMAGES_DIR=images


--------------------------------------------------------------------------------
/src/main/docker/variables-spring.env:
--------------------------------------------------------------------------------
1 | SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/postgres
2 | SPRING_DATASOURCE_USERNAME=postgres
3 | SPRING_DATASOURCE_PASSWORD=postgres
4 | SPRING_JPA_HIBERNATE_DDL_AUTO=update
5 | SPRING_JPA_DATABASE_PLATFORM=org.hibernate.dialect.PostgreSQLDialect


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/BookingBot2Application.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot;
 2 | 
 3 | import org.springframework.boot.SpringApplication;
 4 | import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 | 
 6 | @SpringBootApplication
 7 | public class BookingBot2Application {
 8 | 
 9 |     public static void main(String[] args) {
10 |         SpringApplication.run(BookingBot2Application.class, args);
11 |     }
12 | 
13 | }
14 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/bot/Bot.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.bot;
 2 | 
 3 | import lombok.RequiredArgsConstructor;
 4 | import org.springframework.beans.factory.annotation.Value;
 5 | import org.springframework.stereotype.Component;
 6 | import org.telegram.telegrambots.bots.TelegramLongPollingBot;
 7 | import org.telegram.telegrambots.meta.api.objects.Update;
 8 | import ru.booking.bot.command.Command;
 9 | import ru.booking.bot.command.CommandContainer;
10 | 
11 | import java.util.HashMap;
12 | import java.util.Map;
13 | 
14 | @RequiredArgsConstructor
15 | @Component
16 | public class Bot extends TelegramLongPollingBot {
17 | 
18 |     @Value("${bot.username}")
19 |     private String botUsername;
20 | 
21 |     @Value("${bot.token}")
22 |     private String botToken;
23 | 
24 |     private final CommandContainer commandContainer;
25 |     private final Map<Long, Command> currentUserCommands = new HashMap<>();
26 | 
27 |     @Override
28 |     public void onUpdateReceived(Update update) {
29 |         Long userId = UpdateUtil.getUserId(update);
30 |         String input = UpdateUtil.getInput(update);
31 | 
32 |         boolean isFinished = false;
33 |         if (commandContainer.hasCommand(input)) {   // user starts new command
34 |             Command command = commandContainer.getCommand(input);
35 |             currentUserCommands.put(userId, command);
36 |             isFinished = command.execute(update, true);
37 |         } else if (currentUserCommands.containsKey(userId)) {                                    // user continues some command
38 |             isFinished = currentUserCommands.get(userId).execute(update, false);
39 |         }
40 | 
41 |         if (isFinished) {
42 |             currentUserCommands.remove(userId);
43 |         }
44 |     }
45 | 
46 |     @Override
47 |     public String getBotUsername() {
48 |         return botUsername;
49 |     }
50 | 
51 |     @Override
52 |     public String getBotToken() {
53 |         return botToken;
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/bot/BotService.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.bot;
 2 | 
 3 | import org.telegram.telegrambots.meta.api.methods.send.SendPhoto;
 4 | import org.telegram.telegrambots.meta.api.objects.Update;
 5 | import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboard;
 6 | import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 7 | 
 8 | import java.util.List;
 9 | import java.util.Map;
10 | 
11 | public interface BotService {
12 | 
13 |     void sendText(Long chatId, String text);
14 |     void sendWithKeyboard(Long chatId, String text, List<Button> buttons);
15 |     void sendMarkup(Long chatId, String text, ReplyKeyboard markup);
16 |     void sendPhoto(SendPhoto sendPhoto, List<Button> buttons);
17 |     String downloadPhoto(Update update) throws TelegramApiException;
18 | 
19 | }
20 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/bot/BotServiceImpl.java:
--------------------------------------------------------------------------------
  1 | package ru.booking.bot.bot;
  2 | 
  3 | import lombok.RequiredArgsConstructor;
  4 | import org.springframework.beans.factory.annotation.Value;
  5 | import org.springframework.stereotype.Component;
  6 | import org.telegram.telegrambots.meta.api.methods.GetFile;
  7 | import org.telegram.telegrambots.meta.api.methods.ParseMode;
  8 | import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
  9 | import org.telegram.telegrambots.meta.api.methods.send.SendPhoto;
 10 | import org.telegram.telegrambots.meta.api.objects.Update;
 11 | import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
 12 | import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboard;
 13 | import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
 14 | import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 15 | 
 16 | import java.io.File;
 17 | import java.util.ArrayList;
 18 | import java.util.List;
 19 | 
 20 | @RequiredArgsConstructor
 21 | @Component
 22 | public class BotServiceImpl implements BotService {
 23 | 
 24 |     private final Bot bot;
 25 | 
 26 |     @Value("${bot.images-dir}")
 27 |     private String imagesDir;
 28 | 
 29 |     @Override
 30 |     public void sendText(Long chatId, String text) {
 31 |         SendMessage send = new SendMessage();
 32 |         send.setChatId(chatId.toString());
 33 |         send.setText(text);
 34 |         send.setParseMode(ParseMode.MARKDOWN);
 35 |         try {
 36 |             bot.execute(send);
 37 |         } catch (TelegramApiException e) {
 38 |             e.printStackTrace();
 39 |         }
 40 |     }
 41 | 
 42 |     @Override
 43 |     public void sendWithKeyboard(Long chatId, String text, List<Button> buttons) {
 44 |         SendMessage send = new SendMessage();
 45 |         send.setChatId(chatId.toString());
 46 |         send.setText(text);
 47 |         send.setReplyMarkup(inlineKeyboard(buttons));
 48 |         try {
 49 |             bot.execute(send);
 50 |         } catch (TelegramApiException e) {
 51 |             e.printStackTrace();
 52 |         }
 53 |     }
 54 | 
 55 |     @Override
 56 |     public void sendMarkup(Long chatId, String text, ReplyKeyboard markup) {
 57 |         SendMessage send = new SendMessage();
 58 |         send.setChatId(chatId.toString());
 59 |         send.setText(text);
 60 |         send.setParseMode(ParseMode.MARKDOWN);
 61 |         send.setReplyMarkup(markup);
 62 |         try {
 63 |             bot.execute(send);
 64 |         } catch (TelegramApiException e) {
 65 |             e.printStackTrace();
 66 |         }
 67 |     }
 68 | 
 69 |     @Override
 70 |     public void sendPhoto(SendPhoto sendPhoto, List<Button> buttons) {
 71 |         sendPhoto.setReplyMarkup(inlineKeyboard(buttons));
 72 |         sendPhoto.setParseMode(ParseMode.MARKDOWN);
 73 | 
 74 |         try {
 75 |             bot.execute(sendPhoto);
 76 |         } catch (TelegramApiException e) {
 77 |             e.printStackTrace();
 78 |         }
 79 |     }
 80 | 
 81 |     @Override
 82 |     public String downloadPhoto(Update update) throws TelegramApiException {
 83 |         String fileId = update.getMessage().getPhoto().get(2).getFileId();
 84 |         String filePath = imagesDir + "/" + fileId + ".jpeg";
 85 |         bot.downloadFile(bot.execute(new GetFile(fileId)), new File(filePath));
 86 |         return filePath;
 87 |     }
 88 | 
 89 |     private InlineKeyboardMarkup inlineKeyboard(List<Button> buttons) {
 90 |         InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
 91 |         List<List<InlineKeyboardButton>> totalList = new ArrayList<>();
 92 | 
 93 |         for (Button button : buttons) {
 94 |             List<InlineKeyboardButton> keyboardButtonRow = new ArrayList<>();
 95 | 
 96 |             InlineKeyboardButton inlineButton = new InlineKeyboardButton(button.getLabel());
 97 |             inlineButton.setCallbackData(button.getCallBack());
 98 |             keyboardButtonRow.add(inlineButton);
 99 |             totalList.add(keyboardButtonRow);
100 |         }
101 |         inlineKeyboardMarkup.setKeyboard(totalList);
102 | 
103 |         return inlineKeyboardMarkup;
104 |     }
105 | 
106 | }
107 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/bot/Button.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.bot;
 2 | 
 3 | import lombok.Data;
 4 | 
 5 | @Data
 6 | public class Button {
 7 |     String label;
 8 |     String callBack;
 9 | 
10 |     public Button(String callBack, String label) {
11 |         this.callBack = callBack;
12 |         this.label = label;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/bot/Runner.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.bot;
 2 | 
 3 | import lombok.RequiredArgsConstructor;
 4 | import org.springframework.boot.context.event.ApplicationReadyEvent;
 5 | import org.springframework.context.event.EventListener;
 6 | import org.springframework.stereotype.Component;
 7 | import org.telegram.telegrambots.meta.TelegramBotsApi;
 8 | import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 9 | import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
10 | 
11 | @RequiredArgsConstructor
12 | @Component
13 | public class Runner {
14 | 
15 |     private final Bot bot;
16 | 
17 |     @EventListener(ApplicationReadyEvent.class)
18 |     public void registerBot() {
19 |         try {
20 |             TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);
21 |             botsApi.registerBot(bot);
22 | 
23 |         } catch (TelegramApiException e) {
24 |             e.printStackTrace();
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/bot/UpdateUtil.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.bot;
 2 | 
 3 | import org.telegram.telegrambots.meta.api.objects.Update;
 4 | 
 5 | public class UpdateUtil {
 6 |     public static long getUserId(Update update) {
 7 |         return update.hasCallbackQuery()
 8 |                 ? update.getCallbackQuery().getMessage().getChatId()
 9 |                 : update.getMessage().getChatId();
10 |     }
11 | 
12 |     public static String getInput(Update update) {
13 |         return update.hasCallbackQuery()
14 |                 ? update.getCallbackQuery().getData()
15 |                 : update.getMessage().getText();
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/Command.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.command;
 2 | 
 3 | import org.springframework.beans.factory.annotation.Autowired;
 4 | import org.telegram.telegrambots.meta.api.objects.Update;
 5 | 
 6 | public interface Command {
 7 |     boolean execute(Update update,  boolean isBeginning);
 8 |     CommandName getName();
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/CommandContainer.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.command;
 2 | 
 3 | import org.springframework.context.ApplicationContext;
 4 | import org.springframework.stereotype.Component;
 5 | 
 6 | import java.util.HashMap;
 7 | import java.util.Map;
 8 | 
 9 | @Component
10 | public class CommandContainer {
11 | 
12 |     private final ApplicationContext context;
13 |     private final Map<String, Class<? extends Command>> commandClasses = new HashMap<>();
14 | 
15 |     public CommandContainer(ApplicationContext context) {
16 |         this.context = context;
17 | 
18 |         for (CommandName commandName : CommandName.values()) {
19 |             commandClasses.put(commandName.getText(), commandName.getClassName());
20 |         }
21 |     }
22 | 
23 |     public Command getCommand(String commandName) {
24 |         return context.getBean(commandClasses.get(commandName));
25 |     }
26 | 
27 |     public boolean hasCommand(String name) {
28 |         return commandClasses.containsKey(name);
29 |     }
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/CommandName.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.command;
 2 | 
 3 | import lombok.Getter;
 4 | import lombok.RequiredArgsConstructor;
 5 | import ru.booking.bot.command.impl.*;
 6 | 
 7 | @RequiredArgsConstructor
 8 | @Getter
 9 | public enum CommandName {
10 | 
11 |     ADD_OBJECT("Добавить объект", AddObject.class),
12 |     EDIT_OBJECT("Редактировать объект", EditObject.class),
13 |     MY_BOOKINGS("Мои бронирования", MyBookings.class),
14 |     NEW_BOOKING("Забронировать", NewBooking.class),
15 |     START("/start", Start.class);
16 | 
17 |     private final String text;
18 |     private final Class<? extends Command> className;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/KeyboardMaker.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.command;
 2 | 
 3 | import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboardMarkup;
 4 | import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardRow;
 5 | import ru.booking.bot.models.User;
 6 | 
 7 | import java.util.ArrayList;
 8 | 
 9 | public class KeyboardMaker {
10 |     public static ReplyKeyboardMarkup getKeyboard(User user) {
11 |         return user.isAdmin() ? getAdminKeyboard() : getCustomerKeyboard();
12 |     }
13 | 
14 |     public static ReplyKeyboardMarkup getAdminKeyboard() {
15 |         KeyboardRow keyboardRow1 = new KeyboardRow();
16 |         keyboardRow1.add(CommandName.NEW_BOOKING.getText());
17 |         keyboardRow1.add(CommandName.MY_BOOKINGS.getText());
18 | 
19 |         KeyboardRow keyboardRow2 = new KeyboardRow();
20 |         keyboardRow2.add(CommandName.ADD_OBJECT.getText());
21 |         keyboardRow2.add(CommandName.EDIT_OBJECT.getText());
22 | 
23 |         ArrayList<KeyboardRow> keyBoardRows = new ArrayList<>();
24 |         keyBoardRows.add(keyboardRow1);
25 |         keyBoardRows.add(keyboardRow2);
26 | 
27 |         ReplyKeyboardMarkup replyKeyboard = new ReplyKeyboardMarkup();
28 |         replyKeyboard.setKeyboard(keyBoardRows);
29 |         replyKeyboard.setResizeKeyboard(true);
30 | 
31 |         return replyKeyboard;
32 |     }
33 | 
34 |     public static ReplyKeyboardMarkup getCustomerKeyboard() {
35 |         KeyboardRow keyboardRow1 = new KeyboardRow();
36 |         keyboardRow1.add(CommandName.NEW_BOOKING.getText());
37 |         keyboardRow1.add(CommandName.MY_BOOKINGS.getText());
38 | 
39 |         ArrayList<KeyboardRow> keyBoardRows = new ArrayList<>();
40 |         keyBoardRows.add(keyboardRow1);
41 | 
42 |         ReplyKeyboardMarkup replyKeyboard = new ReplyKeyboardMarkup();
43 |         replyKeyboard.setKeyboard(keyBoardRows);
44 |         replyKeyboard.setResizeKeyboard(true);
45 | 
46 |         return replyKeyboard;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/impl/AddObject.java:
--------------------------------------------------------------------------------
  1 | package ru.booking.bot.command.impl;
  2 | 
  3 | import lombok.RequiredArgsConstructor;
  4 | import org.springframework.beans.factory.annotation.Value;
  5 | import org.springframework.context.annotation.Scope;
  6 | import org.springframework.stereotype.Component;
  7 | import org.telegram.telegrambots.meta.api.objects.Update;
  8 | import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
  9 | import ru.booking.bot.bot.BotService;
 10 | import ru.booking.bot.bot.Button;
 11 | import ru.booking.bot.bot.UpdateUtil;
 12 | import ru.booking.bot.command.Command;
 13 | import ru.booking.bot.command.CommandName;
 14 | import ru.booking.bot.models.BookingObject;
 15 | import ru.booking.bot.models.Type;
 16 | import ru.booking.bot.service.BookingObjectService;
 17 | import ru.booking.bot.service.TypeService;
 18 | 
 19 | import java.time.LocalTime;
 20 | import java.time.format.DateTimeFormatter;
 21 | import java.util.*;
 22 | 
 23 | @RequiredArgsConstructor
 24 | @Component
 25 | @Scope("prototype")
 26 | public class AddObject implements Command {
 27 | 
 28 |     private enum Step {
 29 |         BEGIN,
 30 |         SELECT_CATEGORY,
 31 |         ENTER_CATEGORY_NAME,
 32 |         ENTER_NAME,
 33 |         ENTER_DESCRIPTION,
 34 |         ENTER_AVAILABILITY_START,
 35 |         ENTER_AVAILABILITY_END,
 36 |         UPLOAD_IMAGE
 37 |     }
 38 | 
 39 |     private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH.mm");
 40 | 
 41 |     private static final String EMPTY = "0";
 42 |     private static final String SELECT_CATEGORY = "Выберите категорию";
 43 |     private static final String CREATE_TYPE = "Добавить категорию";
 44 |     private static final String ENTER_NAME = "Введите название";
 45 |     private static final String ENTER_CATEGORY_NAME = "Введите название категории";
 46 |     private static final String ENTER_DESCRIPTION = "Введите описание";
 47 |     private static final String ALREADY_EXIST = "Такой уже есть, введите другое название";
 48 |     private static final String ENTER_AVAILABILITY_START = "Введите время с которого будет доступно бронирование в формате ЧЧ.ММ, например 10.00";
 49 |     private static final String ENTER_AVAILABILITY_END = "Введите до какого времени будет доступно бронирование в формате ЧЧ.ММ, например 19.00";
 50 |     private static final String UPLOAD_IMAGE = "Загрузите изображение";
 51 |     private static final String SKIP = "Пропустить";
 52 |     private static final String DONE = "Готово";
 53 |     private static final String CONFIRMATION = "Готово:\n*%s*\n%s";
 54 |     private static final String UNABLE_TO_UPLOAD = "Не получилось сохранить изображение, попробуйте другое";
 55 | 
 56 |     private final BotService botService;
 57 |     private final TypeService typeService;
 58 |     private final BookingObjectService bookingObjectService;
 59 | 
 60 |     private final Map<Long, Step> usersSteps = new HashMap<>();
 61 |     private boolean isFinished;
 62 |     private BookingObject bookingObject;
 63 | 
 64 |     @Value("${bot.default-start-time}")
 65 |     private String defaultAvailabilityStart;
 66 | 
 67 |     @Value("${bot.default-end-time}")
 68 |     private String defaultAvailabilityEnd;
 69 | 
 70 |     @Override
 71 |     public boolean execute(Update update, boolean isBeginning) {
 72 |         long userId = UpdateUtil.getUserId(update);
 73 |         String input = UpdateUtil.getInput(update);
 74 | 
 75 |         if (!usersSteps.containsKey(userId) || isBeginning) {
 76 |             usersSteps.put(userId, Step.BEGIN);
 77 |         }
 78 | 
 79 |         switch (usersSteps.get(userId)) {
 80 |             case BEGIN -> begin(userId);
 81 |             case SELECT_CATEGORY -> selectCategory(userId, input);
 82 |             case ENTER_CATEGORY_NAME -> enterCategoryName(userId, input);
 83 |             case ENTER_NAME -> enterName(userId, input);
 84 |             case ENTER_DESCRIPTION -> enterDescription(userId, input);
 85 |             case ENTER_AVAILABILITY_START -> enterAvailabilityStart(userId, input);
 86 |             case ENTER_AVAILABILITY_END -> enterAvailabilityEnd(userId, input);
 87 |             case UPLOAD_IMAGE -> uploadOrSkipImage(update);
 88 |         }
 89 | 
 90 |         return isFinished;
 91 |     }
 92 | 
 93 |     @Override
 94 |     public CommandName getName() {
 95 |         return CommandName.ADD_OBJECT;
 96 |     }
 97 | 
 98 |     private void begin(long userId) {
 99 |         botService.sendWithKeyboard(userId, SELECT_CATEGORY, getTypesButtons());
100 |         bookingObject = new BookingObject();
101 |         usersSteps.put(userId, Step.SELECT_CATEGORY);
102 |     }
103 | 
104 |     private void selectCategory(long userId, String input) {
105 |         Optional<Type> typeOpt = typeService.findById(input);
106 |         if (typeOpt.isPresent()) {
107 |             bookingObject.setType(typeOpt.get());
108 |             botService.sendText(userId, ENTER_NAME);
109 |             usersSteps.put(userId, Step.ENTER_NAME);
110 |         } else if (EMPTY.equals(input)) {
111 |             botService.sendText(userId, ENTER_CATEGORY_NAME);
112 |             usersSteps.put(userId, Step.ENTER_CATEGORY_NAME);
113 |         }
114 |     }
115 | 
116 |     private void enterCategoryName(long userId, String input) {
117 |         Type type = new Type();
118 |         type.setName(input);
119 |         typeService.save(type);
120 | 
121 |         botService.sendText(userId, DONE);
122 |         usersSteps.put(userId, Step.BEGIN);
123 |     }
124 | 
125 |     private void enterName(long userId, String input) {
126 |         List<BookingObject> objectList = bookingObjectService.findByName(input);
127 |         if (objectList.isEmpty()) {
128 |             bookingObject.setName(input);
129 | 
130 |             botService.sendWithKeyboard(userId, ENTER_DESCRIPTION, getSkipButton());
131 |             usersSteps.put(userId, Step.ENTER_DESCRIPTION);
132 |         } else {
133 |             botService.sendText(userId, ALREADY_EXIST);
134 |         }
135 |     }
136 | 
137 |     private void enterDescription(long userId, String input) {
138 |         String description = EMPTY.equals(input) ? "" : input;
139 |         bookingObject.setDescription(description);
140 | 
141 |         botService.sendWithKeyboard(userId, ENTER_AVAILABILITY_START, getSkipButton());
142 |         usersSteps.put(userId, Step.ENTER_AVAILABILITY_START);
143 |     }
144 | 
145 |     private void enterAvailabilityStart(long userId, String input) {
146 |         String availability = EMPTY.equals(input) ? defaultAvailabilityStart : input;
147 |         bookingObject.setAvailableFrom(LocalTime.parse(availability, timeFormatter));
148 | 
149 |         botService.sendWithKeyboard(userId, ENTER_AVAILABILITY_END, getSkipButton());
150 |         usersSteps.put(userId, Step.ENTER_AVAILABILITY_END);
151 |     }
152 | 
153 |     private void enterAvailabilityEnd(long userId, String input) {
154 |         String availability = EMPTY.equals(input) ? defaultAvailabilityEnd : input;
155 |         bookingObject.setAvailableTo(LocalTime.parse(availability, timeFormatter));
156 | 
157 |         botService.sendWithKeyboard(userId, UPLOAD_IMAGE, getSkipButton());
158 |         usersSteps.put(userId, Step.UPLOAD_IMAGE);
159 |     }
160 | 
161 |     private void uploadOrSkipImage(Update update) {
162 |         long userId = UpdateUtil.getUserId(update);
163 |         String input = UpdateUtil.getInput(update);
164 |         if (EMPTY.equals(input)) {
165 |             bookingObjectService.save(bookingObject);
166 |             botService.sendText(userId, getConfirmationText());
167 |         } else if (update.getMessage().hasPhoto()) {
168 |             try {
169 |                 String filePath = botService.downloadPhoto(update);
170 |                 bookingObject.setImage(filePath);
171 |                 bookingObjectService.save(bookingObject);
172 |                 botService.sendText(userId, getConfirmationText());
173 | 
174 |                 usersSteps.put(userId, Step.BEGIN);
175 |                 isFinished = true;
176 |             } catch (TelegramApiException e) {
177 |                 botService.sendText(userId, UNABLE_TO_UPLOAD);
178 |                 e.printStackTrace();
179 |             }
180 |         }
181 |     }
182 | 
183 |     private List<Button> getTypesButtons() {
184 |         List<Button> typesButtons = new ArrayList<>();
185 |         List<Type> typesList = typeService.findAll();
186 |         typesList.forEach(type -> typesButtons.add(new Button(String.valueOf(type.getId()), type.getName())));
187 |         typesButtons.add(new Button(EMPTY, CREATE_TYPE));
188 |         return typesButtons;
189 |     }
190 | 
191 |     private String getConfirmationText() {
192 |         return CONFIRMATION.formatted(bookingObject.getName(), bookingObject.getDescription());
193 |     }
194 | 
195 |     private List<Button> getSkipButton() {
196 |         return List.of(new Button(EMPTY, SKIP));
197 |     }
198 | }
199 | 
200 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/impl/EditObject.java:
--------------------------------------------------------------------------------
  1 | package ru.booking.bot.command.impl;
  2 | 
  3 | import lombok.RequiredArgsConstructor;
  4 | import org.slf4j.Logger;
  5 | import org.slf4j.LoggerFactory;
  6 | import org.springframework.context.annotation.Scope;
  7 | import org.springframework.stereotype.Component;
  8 | import org.telegram.telegrambots.meta.api.objects.Update;
  9 | import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 10 | import ru.booking.bot.bot.BotService;
 11 | import ru.booking.bot.bot.Button;
 12 | import ru.booking.bot.bot.UpdateUtil;
 13 | import ru.booking.bot.command.Command;
 14 | import ru.booking.bot.command.CommandName;
 15 | import ru.booking.bot.models.BookingObject;
 16 | import ru.booking.bot.models.Type;
 17 | import ru.booking.bot.service.BookingObjectService;
 18 | import ru.booking.bot.service.TypeService;
 19 | 
 20 | import java.time.LocalTime;
 21 | import java.time.format.DateTimeFormatter;
 22 | import java.time.format.DateTimeParseException;
 23 | import java.util.*;
 24 | 
 25 | @RequiredArgsConstructor
 26 | @Component
 27 | @Scope("prototype")
 28 | public class EditObject implements Command {
 29 | 
 30 |     private enum Step {
 31 |         BEGIN,
 32 |         SELECT_CATEGORY,
 33 |         SELECT_OBJECT,
 34 |         SELECT_ACTION,
 35 |         CHANGE_NAME,
 36 |         CHANGE_DESCRIPTION,
 37 |         CHANGE_AVAILABILITY_FROM,
 38 |         CHANGE_AVAILABILITY_TO,
 39 |         CHANGE_CATEGORY,
 40 |         CHANGE_IMAGE,
 41 |         DELETE
 42 |     }
 43 | 
 44 |     private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH.mm");
 45 | 
 46 |     private static final String CANCEL_VALUE = "-1";
 47 |     private static final String SELECT_CATEGORY = "Выберите категорию";
 48 |     private static final String SELECT_OBJECT = "Выберите кого изменить";
 49 |     private static final String CHANGE_NAME = "Изменить название";
 50 |     private static final String CHANGE_DESCRIPTION = "Изменить описание";
 51 |     private static final String CHANGE_AVAILABILITY = "Изменить интервал доступности";
 52 |     private static final String CHANGE_CATEGORY = "Изменить категорию";
 53 |     private static final String CHANGE_IMAGE = "Изменить изображение";
 54 |     private static final String DELETE = "Удалить";
 55 |     private static final String CANCEL = "Отмена";
 56 |     private static final String SELECT_ACTION = "Выберите действие";
 57 |     private static final String ENTER_NEW_NAME = "Введите новое название";
 58 |     private static final String ENTER_NEW_DESCRIPTION = "Введите новое описание";
 59 |     private static final String ENTER_AVAILABLE_FROM = "Введите время с которого будет доступно бронирование в формате ЧЧ.ММ, например 10.00";
 60 |     private static final String ENTER_AVAILABLE_TO = "Введите до какого времени будет доступно бронирование в формате ЧЧ.ММ, например 19.00";
 61 |     private static final String TOO_EARLY_TIME = "Время должно быть не раньше времени начала.\nВведите время окончания снова";
 62 |     private static final String INCORRECT_TIME_FORMAT = "Не получилось, проверьте что формат времени правильный: ЧЧ.ММ\nНапример 12.30";
 63 |     private static final String SELECT_NEW_CATEGORY = "Выберите новую категорию";
 64 |     private static final String UPLOAD_NEW_IMAGE = "Загрузите новое изображение";
 65 |     private static final String CONFIRM_DELETING = "Вы уверены что хотите удалить %s?";
 66 |     private static final String DONE = "Готово";
 67 |     private static final String UNABLE_TO_UPLOAD = "Не получилось сохранить изображение, попробуйте другое";
 68 | 
 69 |     private final BotService botService;
 70 |     private final TypeService typeService;
 71 |     private final BookingObjectService bookingObjectService;
 72 | 
 73 |     private final Map<Long, Step> usersSteps = new HashMap<>();
 74 |     private boolean isFinished;
 75 |     private BookingObject bookingObject;
 76 |     
 77 |     @Override
 78 |     public boolean execute(Update update, boolean isBeginning) {
 79 |         long userId = UpdateUtil.getUserId(update);
 80 |         String input = UpdateUtil.getInput(update);
 81 | 
 82 |         if (!usersSteps.containsKey(userId) || isBeginning) {
 83 |             usersSteps.put(userId, Step.BEGIN);
 84 |         }
 85 | 
 86 |         switch (usersSteps.get(userId)) {
 87 |             case BEGIN -> begin(userId);
 88 |             case SELECT_CATEGORY -> selectCategory(userId, input);
 89 |             case SELECT_OBJECT -> selectObject(userId, input);
 90 |             case SELECT_ACTION -> selectAction(userId, input);
 91 |             case CHANGE_NAME -> changeName(userId, input);
 92 |             case CHANGE_DESCRIPTION -> changeDescription(userId, input);
 93 |             case CHANGE_AVAILABILITY_FROM -> changeAvailabilityFrom(userId, input);
 94 |             case CHANGE_AVAILABILITY_TO -> changeAvailabilityTo(userId, input);
 95 |             case CHANGE_CATEGORY -> changeCategory(userId, input);
 96 |             case CHANGE_IMAGE -> changeImage(update);
 97 |             case DELETE -> delete(userId);
 98 |         }
 99 | 
100 |         return isFinished;
101 |     }
102 | 
103 |     @Override
104 |     public CommandName getName() {
105 |         return CommandName.EDIT_OBJECT;
106 |     }
107 | 
108 |     private void begin(long userId) {
109 |         botService.sendWithKeyboard(userId, SELECT_CATEGORY, getTypesButtons());
110 |         usersSteps.put(userId, Step.SELECT_CATEGORY);
111 |     }
112 | 
113 |     private void selectCategory(long userId, String input) {
114 |         botService.sendWithKeyboard(userId, SELECT_OBJECT, getObjectsButtons(input));
115 |         usersSteps.put(userId, Step.SELECT_OBJECT);
116 |     }
117 | 
118 |     private void selectObject(long userId, String input) {
119 |         Optional<BookingObject> objectOpt = bookingObjectService.findById(input);
120 |         if (objectOpt.isPresent()) {
121 |             bookingObject = objectOpt.get();
122 |             botService.sendWithKeyboard(userId, SELECT_ACTION, getActionsButtons());
123 |             usersSteps.put(userId, Step.SELECT_ACTION);
124 |         }
125 |     }
126 | 
127 |     private void selectAction(long userId, String input) {
128 |         try {
129 |             Step step = Step.valueOf(input);
130 |             switch (step) {
131 |                 case CHANGE_NAME -> botService.sendText(userId, ENTER_NEW_NAME);
132 |                 case CHANGE_DESCRIPTION -> botService.sendText(userId, ENTER_NEW_DESCRIPTION);
133 |                 case CHANGE_AVAILABILITY_FROM -> botService.sendText(userId, ENTER_AVAILABLE_FROM);
134 |                 case CHANGE_CATEGORY -> botService.sendWithKeyboard(userId, SELECT_NEW_CATEGORY, getTypesButtons());
135 |                 case CHANGE_IMAGE -> botService.sendText(userId, UPLOAD_NEW_IMAGE);
136 |                 case DELETE -> botService.sendWithKeyboard(userId,
137 |                         CONFIRM_DELETING.formatted(bookingObject.getName()), getConfirmButtons());
138 |             }
139 | 
140 |             usersSteps.put(userId, step);
141 |         } catch (IllegalArgumentException ignored) {}
142 |     }
143 | 
144 |     private void changeName(long userId, String input) {
145 |         bookingObject.setName(input);
146 |         confirmChanges(userId);
147 |     }
148 | 
149 |     private void changeDescription(long userId, String input) {
150 |         bookingObject.setDescription(input);
151 |         confirmChanges(userId);
152 |     }
153 | 
154 |     private void changeAvailabilityFrom(long userId, String input) {
155 |         try {
156 |             LocalTime availability = LocalTime.parse(input, timeFormatter);
157 |             bookingObject.setAvailableFrom(availability);
158 | 
159 |             botService.sendText(userId, ENTER_AVAILABLE_TO);
160 |             usersSteps.put(userId, Step.CHANGE_AVAILABILITY_TO);
161 |         } catch (DateTimeParseException e) {
162 |             botService.sendText(userId, INCORRECT_TIME_FORMAT);
163 |         }
164 |     }
165 | 
166 |     private void changeAvailabilityTo(long userId, String input) {
167 |         try {
168 |             LocalTime availability = LocalTime.parse(input, timeFormatter);
169 |             if (availability.isBefore(bookingObject.getAvailableFrom())) {
170 |                 botService.sendText(userId, TOO_EARLY_TIME);
171 |             } else {
172 |                 bookingObject.setAvailableTo(availability);
173 |                 confirmChanges(userId);
174 |             }
175 |         } catch (DateTimeParseException e) {
176 |             botService.sendText(userId, INCORRECT_TIME_FORMAT);
177 |         }
178 |     }
179 | 
180 |     private void changeCategory(long userId, String input) {
181 |         Optional<Type> typeOpt = typeService.findById(input);
182 |         typeOpt.ifPresent(type -> bookingObject.setType(type));
183 |         confirmChanges(userId);
184 |     }
185 | 
186 |     private void changeImage(Update update) {
187 |         Long userId = UpdateUtil.getUserId(update);
188 |         if (update.getMessage().hasPhoto()) {
189 |             try {
190 |                 String filePath = botService.downloadPhoto(update);
191 |                 bookingObject.setImage(filePath);
192 |                 confirmChanges(userId);
193 |             } catch (TelegramApiException e) {
194 |                 botService.sendText(userId, UNABLE_TO_UPLOAD);
195 |                 e.printStackTrace();
196 |             }
197 |         } else {
198 |             botService.sendText(userId, UPLOAD_NEW_IMAGE);
199 |         }
200 |     }
201 | 
202 |     private void delete(long userId) {
203 |         bookingObjectService.delete(bookingObject);
204 |         botService.sendText(userId, DONE);
205 |         usersSteps.put(userId, Step.BEGIN);
206 |         isFinished = true;
207 |     }
208 | 
209 |     private void confirmChanges(long userId) {
210 |         bookingObjectService.save(bookingObject);
211 |         botService.sendText(userId, DONE);
212 |         usersSteps.put(userId, Step.BEGIN);
213 |         isFinished = true;
214 |     }
215 | 
216 |     private List<Button> getTypesButtons() {
217 |         List<Button> typesButtons = new ArrayList<>();
218 |         List<Type> typesList = typeService.findAll();
219 |         typesList.forEach(type -> typesButtons.add(new Button(String.valueOf(type.getId()), type.getName())));
220 |         return typesButtons;
221 |     }
222 | 
223 |     private List<Button> getObjectsButtons(String typeId) {
224 |         List<Button> typesButtons = new ArrayList<>();
225 |         List<BookingObject> objectsList = bookingObjectService.findByTypeId(typeId);
226 |         objectsList.forEach(type -> typesButtons.add(new Button(String.valueOf(type.getId()), type.getName())));
227 |         return typesButtons;
228 |     }
229 | 
230 |     private List<Button> getActionsButtons() {
231 |         return List.of(
232 |                 new Button(Step.CHANGE_NAME.toString(), CHANGE_NAME),
233 |                 new Button(Step.CHANGE_NAME.toString(), CHANGE_NAME),
234 |                 new Button(Step.CHANGE_DESCRIPTION.toString(), CHANGE_DESCRIPTION),
235 |                 new Button(Step.CHANGE_AVAILABILITY_FROM.toString(), CHANGE_AVAILABILITY),
236 |                 new Button(Step.CHANGE_CATEGORY.toString(), CHANGE_CATEGORY),
237 |                 new Button(Step.CHANGE_IMAGE.toString(), CHANGE_IMAGE),
238 |                 new Button(Step.DELETE.toString(), DELETE)
239 |         );
240 |     }
241 | 
242 |     private List<Button> getConfirmButtons() {
243 |         return List.of(
244 |                 new Button(String.valueOf(bookingObject.getId()), DELETE),
245 |                 new Button(CANCEL_VALUE, CANCEL)
246 |         );
247 |     }
248 | 
249 | }
250 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/impl/MyBookings.java:
--------------------------------------------------------------------------------
  1 | package ru.booking.bot.command.impl;
  2 | 
  3 | import lombok.RequiredArgsConstructor;
  4 | import org.springframework.context.annotation.Scope;
  5 | import org.springframework.stereotype.Component;
  6 | import org.telegram.telegrambots.meta.api.objects.Update;
  7 | import ru.booking.bot.bot.BotService;
  8 | import ru.booking.bot.bot.Button;
  9 | import ru.booking.bot.bot.UpdateUtil;
 10 | import ru.booking.bot.command.Command;
 11 | import ru.booking.bot.command.CommandName;
 12 | import ru.booking.bot.models.Booking;
 13 | import ru.booking.bot.models.User;
 14 | import ru.booking.bot.service.BookingService;
 15 | import ru.booking.bot.service.UserService;
 16 | 
 17 | import java.util.*;
 18 | 
 19 | @RequiredArgsConstructor
 20 | @Component
 21 | @Scope("prototype")
 22 | public class MyBookings implements Command {
 23 | 
 24 |     private enum Step {
 25 |         BEGIN,
 26 |         DELETE,
 27 |         CONFIRM
 28 |     }
 29 | 
 30 |     private static final String NO_BOOKINGS = "У вас пока нет бронирований";
 31 |     private static final String DELETE = "Удалить";
 32 |     private static final String CANCEL = "Отмена";
 33 |     private static final String DONE = "Готово";
 34 |     private static final String CONFIRM = "Вы уверены что хотите удалить бронь?";
 35 | 
 36 |     private final BotService botService;
 37 |     private final BookingService bookingService;
 38 |     private final UserService userService;
 39 | 
 40 |     private final Map<Long, Step> usersSteps = new HashMap<>();
 41 |     private boolean isFinished;
 42 | 
 43 |     public boolean execute(Update update, boolean isBeginning) {
 44 |         Long userId = UpdateUtil.getUserId(update);
 45 |         String input = UpdateUtil.getInput(update);
 46 | 
 47 |         if (!usersSteps.containsKey(userId) || isBeginning) {
 48 |             usersSteps.put(userId, Step.BEGIN);
 49 |         }
 50 | 
 51 |         switch (usersSteps.get(userId)) {
 52 |             case BEGIN -> begin(update);
 53 |             case DELETE -> deleteBooking(userId, input);
 54 |             case CONFIRM -> confirmDeleting(userId, input);
 55 |         }
 56 | 
 57 |         return isFinished;
 58 |     }
 59 | 
 60 |     @Override
 61 |     public CommandName getName() {
 62 |         return CommandName.MY_BOOKINGS;
 63 |     }
 64 | 
 65 |     private void begin(Update update) {
 66 |         long userId = UpdateUtil.getUserId(update);
 67 |         Optional<User> userOpt = userService.findById(userId);
 68 |         if (userOpt.isPresent()) {
 69 |             User user = userOpt.get();
 70 |             List<Booking> bookingList = user.isAdmin() ? bookingService.findAll() : bookingService.findByUserId(userId);
 71 | 
 72 |             if (bookingList.isEmpty()) {
 73 |                 botService.sendText(userId, NO_BOOKINGS);
 74 |             } else {
 75 |                 bookingList.forEach(booking -> botService.sendWithKeyboard(userId,
 76 |                         booking.getFullText(user.isAdmin()), getDeleteButton(booking)));
 77 |             }
 78 | 
 79 |             usersSteps.put(userId, Step.DELETE);
 80 |         }
 81 |     }
 82 | 
 83 |     private void deleteBooking(long userId, String input) {
 84 |         Optional<Booking> bookingOpt = bookingService.findById(input);
 85 |         if (bookingOpt.isPresent()) {
 86 |             botService.sendWithKeyboard(userId, CONFIRM, getConfirmButtons(bookingOpt.get()));
 87 |             usersSteps.put(userId, Step.CONFIRM);
 88 |         }
 89 |     }
 90 | 
 91 |     private void confirmDeleting(long userId, String input) {
 92 |         Optional<Booking> bookingOpt = bookingService.findById(input);
 93 |         if (bookingOpt.isPresent()) {
 94 |             bookingService.delete(bookingOpt.get());
 95 |             botService.sendText(userId, DONE);
 96 |         }
 97 | 
 98 |         usersSteps.put(userId, Step.BEGIN);
 99 |         isFinished = true;
100 |     }
101 | 
102 |     private List<Button> getDeleteButton(Booking booking) {
103 |         return List.of(new Button(String.valueOf(booking.getId()), DELETE));
104 |     }
105 | 
106 |     private List<Button> getConfirmButtons(Booking booking) {
107 |         return List.of(
108 |                 new Button(String.valueOf(booking.getId()), DELETE),
109 |                 new Button("0", CANCEL)
110 |         );
111 |     }
112 | 
113 | }
114 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/impl/NewBooking.java:
--------------------------------------------------------------------------------
  1 | package ru.booking.bot.command.impl;
  2 | 
  3 | import lombok.RequiredArgsConstructor;
  4 | import org.springframework.context.annotation.Scope;
  5 | import org.springframework.stereotype.Component;
  6 | import org.telegram.telegrambots.meta.api.methods.ParseMode;
  7 | import org.telegram.telegrambots.meta.api.methods.send.SendPhoto;
  8 | import org.telegram.telegrambots.meta.api.objects.InputFile;
  9 | import org.telegram.telegrambots.meta.api.objects.Update;
 10 | import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
 11 | import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
 12 | import ru.booking.bot.bot.Button;
 13 | import ru.booking.bot.bot.UpdateUtil;
 14 | import ru.booking.bot.command.Command;
 15 | import ru.booking.bot.command.CommandName;
 16 | import ru.booking.bot.models.Booking;
 17 | import ru.booking.bot.bot.BotService;
 18 | import ru.booking.bot.models.BookingObject;
 19 | import ru.booking.bot.models.User;
 20 | import ru.booking.bot.service.BookingObjectService;
 21 | import ru.booking.bot.service.BookingService;
 22 | import ru.booking.bot.service.TypeService;
 23 | import ru.booking.bot.service.UserService;
 24 | 
 25 | import java.io.File;
 26 | import java.time.LocalDate;
 27 | import java.time.LocalDateTime;
 28 | import java.time.LocalTime;
 29 | import java.time.format.DateTimeFormatter;
 30 | import java.time.format.DateTimeParseException;
 31 | import java.util.*;
 32 | 
 33 | @RequiredArgsConstructor
 34 | @Component
 35 | @Scope("prototype")
 36 | public class NewBooking implements Command {
 37 | 
 38 |     private enum Step {
 39 |         BEGIN,
 40 |         SELECT_OBJECT,
 41 |         SELECT_DATE,
 42 |         ENTER_TIME_START,
 43 |         ENTER_TIME_END,
 44 |         CONFIRMATION
 45 |     }
 46 | 
 47 |     private static final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
 48 |     private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH.mm");
 49 | 
 50 |     private static final String SELECT_CATEGORY = "Выберите категорию";
 51 |     private static final String NOTHING_FOUND = "Ничего не нашлось";
 52 |     private static final String SELECT_OBJECT = "Выберите что забронировать:";
 53 |     private static final String BOOK = "Забронировать";
 54 |     private static final String SELECT_DATE = "Выберите дату:";
 55 |     private static final String INCORRECT_DAY = "На этот день не получится, выберите другой";
 56 |     private static final String AVAILABLE_SLOTS = "Доступное время:";
 57 |     private static final String ENTER_TIME_START = "Введите время начала в формате ЧЧ.ММ\nНапример 12.30";
 58 |     private static final String TOO_EARLY_TIME_START = "Время должно быть не раньше текущего.\nВведите время начала снова";
 59 |     private static final String ENTER_TIME_END = "Введите время окончания, тоже в формате ЧЧ.ММ";
 60 |     private static final String INCORRECT_TIME_FORMAT = "Не получилось, проверьте что формат времени правильный: ЧЧ.ММ\nНапример 12.30";
 61 |     private static final String TOO_EARLY_TIME_END = "Время окончания не должно быть раньше времени начала.\nВведите время окончания снова";
 62 |     private static final String TIME_INTERSECT = "Ваше время пересекается с уже имеющимся слотом.\nВведите время начала снова";
 63 |     private static final String CONFIRMATION_TEXT = "Готово!\nЗабронировали на %s\nС %s до %s\n%s";
 64 | 
 65 |     private final BotService botService;
 66 |     private final TypeService typeService;
 67 |     private final BookingObjectService bookingObjectService;
 68 |     private final BookingService bookingService;
 69 |     private final UserService userService;
 70 | 
 71 |     private final Map<Long, Step> usersSteps = new HashMap<>();
 72 |     private boolean isFinished;
 73 |     private Booking booking;
 74 | 
 75 |     @Override
 76 |     public boolean execute(Update update, boolean isBeginning) {
 77 |         Long userId = UpdateUtil.getUserId(update);
 78 |         String input = UpdateUtil.getInput(update);
 79 | 
 80 |         if (!usersSteps.containsKey(userId) || isBeginning) {
 81 |             usersSteps.put(userId, Step.BEGIN);
 82 |         }
 83 | 
 84 |         switch (usersSteps.get(userId)) {
 85 |             case BEGIN -> begin(update);
 86 |             case SELECT_OBJECT -> selectObject(userId, input);
 87 |             case SELECT_DATE -> selectDate(userId, input);
 88 |             case ENTER_TIME_START -> enterTimeStart(userId, input);
 89 |             case ENTER_TIME_END -> enterTimeEnd(userId, input);
 90 |             case CONFIRMATION -> confirmation(userId, input);
 91 |         }
 92 | 
 93 |         return isFinished;
 94 |     }
 95 | 
 96 |     @Override
 97 |     public CommandName getName() {
 98 |         return CommandName.NEW_BOOKING;
 99 |     }
100 | 
101 |     private void begin(Update update) {
102 |         long userId = UpdateUtil.getUserId(update);
103 |         List<Button> buttons = new ArrayList<>();
104 | 
105 |         Optional<User> userOpt = userService.findById(userId);
106 |         booking = new Booking();
107 |         booking.setUser(userOpt.orElseGet(() -> userService.create(update)));
108 | 
109 |         typeService.findAll().forEach(type -> buttons.add(new Button(String.valueOf(type.getId()), type.getName())));
110 |         botService.sendWithKeyboard(userId, SELECT_CATEGORY, buttons);
111 |         usersSteps.put(userId, Step.SELECT_OBJECT);
112 |     }
113 | 
114 |     private void selectObject(Long userId, String input) {
115 |         List<BookingObject> objectList = bookingObjectService.findByTypeId(input);
116 | 
117 |         if (objectList.isEmpty()) {
118 |             botService.sendText(userId, NOTHING_FOUND);
119 |             usersSteps.put(userId, Step.BEGIN);
120 |         } else {
121 |             botService.sendText(userId, SELECT_OBJECT);
122 | 
123 |             for (BookingObject object : objectList) {
124 |                 List<Button> buttons = List.of(new Button(String.valueOf(object.getId()), BOOK));
125 |                 if (object.getImage() == null || object.getImage().equals("null") || object.getImage().equals("")) {
126 |                     botService.sendWithKeyboard(userId, object.getFullText(), buttons);
127 |                 } else {
128 |                     botService.sendPhoto(getPhotoMessage(userId, object), buttons);
129 |                 }
130 |             }
131 | 
132 |             usersSteps.put(userId, Step.SELECT_DATE);
133 |         }
134 |     }
135 | 
136 |     private void selectDate(Long userId, String input) {
137 |         Optional<BookingObject> objectOpt = bookingObjectService.findById(input);
138 |         if (objectOpt.isPresent()) {
139 |             booking.setBookingObject(objectOpt.get());
140 | 
141 |             botService.sendMarkup(userId, SELECT_DATE, makeCalendar());
142 |             usersSteps.put(userId, Step.ENTER_TIME_START);
143 |         }
144 |     }
145 | 
146 |     private void enterTimeStart(Long userId, String input) {
147 |         LocalDate selectedDate = LocalDate.parse(input, dateFormatter);
148 |         if (selectedDate.isBefore(LocalDate.now())) {
149 |             botService.sendText(userId, INCORRECT_DAY);
150 |         } else {
151 |             booking.setTimeStart(selectedDate.atStartOfDay());
152 | 
153 |             botService.sendText(userId, AVAILABLE_SLOTS + "\n"
154 |                     + getAvailableSlots(booking.getBookingObject(), selectedDate));
155 |             botService.sendText(userId, ENTER_TIME_START);
156 |             usersSteps.put(userId, Step.ENTER_TIME_END);
157 |         }
158 |     }
159 | 
160 |     private void enterTimeEnd(Long userId, String input) {
161 |         try {
162 |             LocalTime timeStart = LocalTime.parse(input, timeFormatter);
163 |             if (booking.getTimeStart().toLocalDate().atTime(timeStart).isBefore(LocalDateTime.now())) {
164 |                 botService.sendText(userId, TOO_EARLY_TIME_START);
165 |             } else {
166 |                 booking.setTimeStart(booking.getTimeStart().toLocalDate().atTime(timeStart));
167 | 
168 |                 botService.sendText(userId, ENTER_TIME_END);
169 |                 usersSteps.put(userId, Step.CONFIRMATION);
170 |             }
171 |         } catch (DateTimeParseException e) {
172 |             botService.sendText(userId, INCORRECT_TIME_FORMAT);
173 |         }
174 |     }
175 | 
176 |     private void confirmation(Long userId, String input) {
177 |         try {
178 |             LocalTime timeEnd = LocalTime.parse(input, timeFormatter);
179 |             LocalTime timeStart = booking.getTimeStart().toLocalTime();
180 |             if (timeEnd.isBefore(timeStart)) {
181 |                 botService.sendText(userId, TOO_EARLY_TIME_END);
182 |             } else if (!checkSlot(timeStart, timeEnd)) {
183 |                 botService.sendText(userId, TIME_INTERSECT);
184 |                 usersSteps.put(userId, Step.ENTER_TIME_END);
185 |             } else {
186 |                 booking.setTimeEnd(LocalDateTime.of(booking.getTimeStart().toLocalDate(), timeEnd));
187 |                 bookingService.save(booking);
188 | 
189 |                 String confirmationText = String.format(CONFIRMATION_TEXT,
190 |                         booking.getTimeStart().format(dateFormatter), timeStart, timeEnd,
191 |                         booking.getBookingObject().getName());
192 |                 botService.sendText(userId, confirmationText);
193 | 
194 |                 usersSteps.put(userId, Step.BEGIN);
195 |                 isFinished = true;
196 |             }
197 | 
198 |         } catch (DateTimeParseException e) {
199 |             botService.sendText(userId, INCORRECT_TIME_FORMAT);
200 |         }
201 |     }
202 | 
203 |     private InlineKeyboardMarkup makeCalendar() {
204 |         InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
205 |         List<List<InlineKeyboardButton>> totalList = new ArrayList<>();
206 | 
207 |         LocalDate today = LocalDate.now();
208 |         LocalDate day = today.minusDays(today.getDayOfWeek().getValue() - 1);
209 | 
210 |         for(int calendarRow = 0; calendarRow < 4; calendarRow++) {
211 |             List<InlineKeyboardButton> keyboardButtonRow = new ArrayList<>();
212 |             for(int calendarColumn = 0; calendarColumn < 7; calendarColumn++) {
213 |                 InlineKeyboardButton button = new InlineKeyboardButton();
214 |                 button.setText(day.isBefore(today) ? "X" : String.valueOf(day.getDayOfMonth()));
215 |                 button.setCallbackData(day.format(dateFormatter));
216 |                 keyboardButtonRow.add(button);
217 |                 day = day.plusDays(1);
218 |             }
219 |             totalList.add(keyboardButtonRow);
220 |         }
221 |         inlineKeyboardMarkup.setKeyboard(totalList);
222 |         return inlineKeyboardMarkup;
223 |     }
224 | 
225 |     private String getAvailableSlots(BookingObject object, LocalDate date) {
226 |         List<Booking> bookingList = bookingService.findByDateAndObject(date, booking.getBookingObject());
227 | 
228 |         StringBuilder stringBuilder = new StringBuilder();
229 |         stringBuilder.append(object.getAvailableFrom()).append(" - ");
230 |         for (Booking booking: bookingList) {
231 |             stringBuilder.append(booking.getTimeStart().toLocalTime())
232 |                     .append("\n")
233 |                     .append(booking.getTimeEnd().toLocalTime())
234 |                     .append(" - ");
235 |         }
236 |         stringBuilder.append(object.getAvailableTo());
237 | 
238 |         return stringBuilder.toString();
239 |     }
240 | 
241 |     private boolean checkSlot(LocalTime timeStart, LocalTime timeEnd) {
242 |         List<Booking> bookingList = bookingService.findByDateAndObject(booking.getTimeStart().toLocalDate(),
243 |                 booking.getBookingObject());
244 |         for (Booking booking : bookingList) {
245 |             LocalTime start = booking.getTimeStart().toLocalTime();
246 |             LocalTime end = booking.getTimeEnd().toLocalTime();
247 |             if (timeStart.isBefore(end) || timeEnd.isBefore(start)) {
248 |                 return false;
249 |             }
250 |         }
251 | 
252 |         return true;
253 |     }
254 | 
255 |     private SendPhoto getPhotoMessage(long userId, BookingObject object) {
256 |         SendPhoto sendPhoto = new SendPhoto();
257 |         sendPhoto.setChatId(String.valueOf(userId));
258 |         sendPhoto.setParseMode(ParseMode.MARKDOWN);
259 |         sendPhoto.setCaption(object.getFullText());
260 |         sendPhoto.setPhoto(new InputFile(new File(object.getImage())));
261 | 
262 |         return sendPhoto;
263 |     }
264 | 
265 | }
266 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/command/impl/Start.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.command.impl;
 2 | 
 3 | import lombok.RequiredArgsConstructor;
 4 | import org.springframework.context.annotation.Scope;
 5 | import org.springframework.stereotype.Component;
 6 | import org.telegram.telegrambots.meta.api.objects.Update;
 7 | import ru.booking.bot.bot.BotService;
 8 | import ru.booking.bot.bot.UpdateUtil;
 9 | import ru.booking.bot.command.Command;
10 | import ru.booking.bot.command.CommandName;
11 | import ru.booking.bot.command.KeyboardMaker;
12 | import ru.booking.bot.models.User;
13 | import ru.booking.bot.service.UserService;
14 | 
15 | import java.util.Optional;
16 | 
17 | @RequiredArgsConstructor
18 | @Component
19 | @Scope("prototype")
20 | public class Start implements Command {
21 | 
22 |     private static final String GREETING_TEXT = "Привет, выбери одну из кнопок ниже";
23 | 
24 |     private final BotService botService;
25 |     private final UserService userService;
26 | 
27 |     @Override
28 |     public boolean execute(Update update,  boolean isBeginning) {
29 |         Long userId = UpdateUtil.getUserId(update);
30 |         Optional<User> userOpt = userService.findById(userId);
31 |         User user = userOpt.orElseGet(() -> userService.create(update));
32 |         botService.sendMarkup(userId, GREETING_TEXT, KeyboardMaker.getKeyboard(user));
33 |         return true;
34 |     }
35 | 
36 |     @Override
37 |     public CommandName getName() {
38 |         return CommandName.START;
39 |     }
40 | }


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/models/Booking.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.models;
 2 | 
 3 | import jakarta.persistence.*;
 4 | import lombok.Data;
 5 | 
 6 | import java.time.LocalDateTime;
 7 | import java.time.format.DateTimeFormatter;
 8 | 
 9 | @Data
10 | @Entity
11 | @Table(name = "bookings")
12 | public class Booking {
13 | 
14 |     @Id
15 |     @GeneratedValue(strategy = GenerationType.IDENTITY)
16 |     private Long id;
17 | 
18 |     private LocalDateTime timeStart;
19 |     private LocalDateTime timeEnd;
20 |     private boolean isApproved;
21 | 
22 |     @ManyToOne
23 |     private User user;
24 | 
25 |     @ManyToOne
26 |     private BookingObject bookingObject;
27 | 
28 |     public String getFullText(boolean isAdmin) {
29 |         DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
30 |         String text = bookingObject.getName() + "\n"
31 |                 + timeStart.toLocalDate().format(dateFormatter) + "\n"
32 |                 + timeStart.toLocalTime() + " - " + timeEnd.toLocalTime();
33 |         if (isAdmin) {
34 |             text += "\n@" + user.getUsername();
35 |         }
36 | 
37 |         return text;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/models/BookingObject.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.models;
 2 | 
 3 | import jakarta.persistence.*;
 4 | import lombok.Data;
 5 | 
 6 | import java.time.LocalTime;
 7 | 
 8 | @Data
 9 | @Entity
10 | @Table(name = "booking_objects")
11 | public class BookingObject {
12 | 
13 |     @Id
14 |     @GeneratedValue(strategy = GenerationType.IDENTITY)
15 |     private Long id;
16 |     private String name;
17 |     private String description;
18 |     private String image;
19 |     private LocalTime availableFrom;
20 |     private LocalTime availableTo;
21 | 
22 |     @ManyToOne
23 |     private Type type;
24 | 
25 |     public String getFullText() {
26 |         return name + (description == null ? "" : ("\n" + description));
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/models/Type.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.models;
 2 | 
 3 | import jakarta.persistence.*;
 4 | import lombok.Data;
 5 | 
 6 | @Data
 7 | @Entity
 8 | @Table(name = "types")
 9 | public class Type {
10 | 
11 |     @Id
12 |     @GeneratedValue(strategy = GenerationType.IDENTITY)
13 |     private Long id;
14 |     private String name;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/models/User.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.models;
 2 | 
 3 | import jakarta.persistence.Entity;
 4 | import jakarta.persistence.Id;
 5 | import jakarta.persistence.OneToMany;
 6 | import jakarta.persistence.Table;
 7 | import lombok.Data;
 8 | 
 9 | import java.util.List;
10 | 
11 | @Data
12 | @Entity
13 | @Table(name = "users")
14 | public class User {
15 | 
16 |     @Id
17 |     private Long id;
18 |     private String username;
19 |     private boolean isAdmin;
20 | 
21 |     @OneToMany
22 |     private List<Booking> bookings;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/repository/BookingObjectRepository.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.repository;
 2 | 
 3 | import org.springframework.data.repository.CrudRepository;
 4 | import ru.booking.bot.models.BookingObject;
 5 | 
 6 | import java.util.List;
 7 | 
 8 | public interface BookingObjectRepository extends CrudRepository<BookingObject, Long> {
 9 |     List<BookingObject> findByTypeId(long id);
10 |     List<BookingObject> findByName(String name);
11 | }
12 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/repository/BookingRepository.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.repository;
 2 | 
 3 | import jakarta.annotation.Nonnull;
 4 | import org.springframework.data.repository.CrudRepository;
 5 | import ru.booking.bot.models.Booking;
 6 | import ru.booking.bot.models.BookingObject;
 7 | 
 8 | import java.time.LocalDateTime;
 9 | import java.util.List;
10 | 
11 | public interface BookingRepository extends CrudRepository<Booking, Long> {
12 |     @Nonnull
13 |     List<Booking> findAll();
14 |     List<Booking> findByTimeStartBetweenAndBookingObject(LocalDateTime fromTime, LocalDateTime toTime, BookingObject object);
15 |     List<Booking> findByUserId(long userId);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/repository/TypeRepository.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.repository;
 2 | 
 3 | import jakarta.annotation.Nonnull;
 4 | import org.springframework.data.repository.CrudRepository;
 5 | import ru.booking.bot.models.Type;
 6 | 
 7 | import java.util.List;
 8 | 
 9 | public interface TypeRepository extends CrudRepository<Type, Long> {
10 | 
11 |     @Nonnull
12 |     List<Type> findAll();
13 | }
14 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/repository/UserRepository.java:
--------------------------------------------------------------------------------
1 | package ru.booking.bot.repository;
2 | 
3 | import org.springframework.data.repository.CrudRepository;
4 | import ru.booking.bot.models.User;
5 | 
6 | public interface UserRepository extends CrudRepository<User, Long> {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/service/BookingObjectService.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.service;
 2 | 
 3 | import lombok.RequiredArgsConstructor;
 4 | import org.springframework.stereotype.Service;
 5 | import ru.booking.bot.models.BookingObject;
 6 | import ru.booking.bot.repository.BookingObjectRepository;
 7 | 
 8 | import java.util.ArrayList;
 9 | import java.util.List;
10 | import java.util.Optional;
11 | 
12 | @RequiredArgsConstructor
13 | @Service
14 | public class BookingObjectService {
15 | 
16 |     private final BookingObjectRepository bookingObjectRepository;
17 | 
18 |     public Optional<BookingObject> findById(String id) {
19 |         if (id == null || id.isEmpty()) {
20 |             return Optional.empty();
21 |         }
22 | 
23 |         return bookingObjectRepository.findById(Long.parseLong(id));
24 |     }
25 | 
26 |     public List<BookingObject> findByTypeId(String id) {
27 |         if (id == null || id.isEmpty()) {
28 |             return new ArrayList<>();
29 |         }
30 | 
31 |         return bookingObjectRepository.findByTypeId(Long.parseLong(id));
32 |     }
33 | 
34 |     public List<BookingObject> findByName(String name) {
35 |         return bookingObjectRepository.findByName(name);
36 |     }
37 | 
38 |     public void save(BookingObject bookingObject) {
39 |         bookingObjectRepository.save(bookingObject);
40 |     }
41 | 
42 |     public void delete(BookingObject object) {
43 |             bookingObjectRepository.delete(object);
44 |     }
45 | 
46 | }
47 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/service/BookingService.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.service;
 2 | 
 3 | import lombok.RequiredArgsConstructor;
 4 | import org.springframework.stereotype.Service;
 5 | import ru.booking.bot.models.Booking;
 6 | import ru.booking.bot.models.BookingObject;
 7 | import ru.booking.bot.repository.BookingRepository;
 8 | 
 9 | import java.time.LocalDate;
10 | import java.util.List;
11 | import java.util.Optional;
12 | 
13 | @RequiredArgsConstructor
14 | @Service
15 | public class BookingService {
16 | 
17 |     private final BookingRepository bookingRepository;
18 | 
19 |     public List<Booking> findAll() {
20 |         return bookingRepository.findAll();
21 |     }
22 | 
23 |     public Optional<Booking> findById(String id) {
24 |         if (id == null || id.isEmpty()) {
25 |             return Optional.empty();
26 |         }
27 | 
28 |         return bookingRepository.findById(Long.parseLong(id));
29 |     }
30 | 
31 |     public List<Booking> findByDateAndObject(LocalDate date, BookingObject object) {
32 |         return bookingRepository.findByTimeStartBetweenAndBookingObject(date.atStartOfDay(),
33 |                 date.plusDays(1).atStartOfDay(), object);
34 |     }
35 | 
36 |     public List<Booking> findByUserId(long userId) {
37 |         return bookingRepository.findByUserId(userId);
38 |     }
39 | 
40 |     public void save(Booking booking) {
41 |         bookingRepository.save(booking);
42 |     }
43 | 
44 |     public void delete(Booking booking) {
45 |         bookingRepository.delete(booking);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/service/TypeService.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.service;
 2 | 
 3 | import lombok.RequiredArgsConstructor;
 4 | import org.springframework.stereotype.Service;
 5 | import ru.booking.bot.models.Type;
 6 | import ru.booking.bot.repository.TypeRepository;
 7 | 
 8 | import java.util.List;
 9 | import java.util.Optional;
10 | 
11 | @RequiredArgsConstructor
12 | @Service
13 | public class TypeService {
14 | 
15 |     private final TypeRepository typeRepository;
16 | 
17 |     public List<Type> findAll() {
18 |         return typeRepository.findAll();
19 |     }
20 | 
21 |     public Optional<Type> findById(String id) {
22 |         if (id == null || id.isEmpty()) {
23 |             return Optional.empty();
24 |         }
25 | 
26 |         return typeRepository.findById(Long.parseLong(id));
27 |     }
28 | 
29 |     public void save(Type type) {
30 |         typeRepository.save(type);
31 |     }
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/src/main/java/ru/booking/bot/service/UserService.java:
--------------------------------------------------------------------------------
 1 | package ru.booking.bot.service;
 2 | 
 3 | import jakarta.annotation.PostConstruct;
 4 | import lombok.RequiredArgsConstructor;
 5 | import org.springframework.beans.factory.annotation.Value;
 6 | import org.springframework.stereotype.Service;
 7 | import org.telegram.telegrambots.meta.api.objects.Update;
 8 | import ru.booking.bot.bot.UpdateUtil;
 9 | import ru.booking.bot.models.User;
10 | import ru.booking.bot.repository.UserRepository;
11 | 
12 | import java.util.List;
13 | import java.util.Optional;
14 | 
15 | @RequiredArgsConstructor
16 | @Service
17 | public class UserService {
18 | 
19 |     @Value("${bot.admin-usernames}")
20 |     private String adminUsernames;
21 | 
22 |     private final UserRepository userRepository;
23 | 
24 |     public Optional<User> findById(Long id) {
25 |         return userRepository.findById(id);
26 |     }
27 | 
28 |     public User create(Update update) {
29 |         List<String> adminUsernamesList = List.of(adminUsernames.split(","));
30 |         User user = new User();
31 |         user.setId(UpdateUtil.getUserId(update));
32 | 
33 |         String username = update.getMessage().getFrom().getUserName();
34 |         user.setUsername(username);
35 |         user.setAdmin(adminUsernamesList.contains(username));
36 |         userRepository.save(user);
37 | 
38 |         return user;
39 |     }
40 | 
41 |     @PostConstruct
42 |     private void setAdmins() {
43 |         List<String> adminUsernamesList = List.of(adminUsernames.split(","));
44 |         List<User> usersList = (List<User>) userRepository.findAll();
45 |         for (User user : usersList) {
46 |             user.setAdmin(adminUsernamesList.contains(user.getUsername()));
47 |         }
48 | 
49 |         userRepository.saveAll(usersList);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/main/resources/application.properties:
--------------------------------------------------------------------------------
 1 | # database settings
 2 | spring.datasource.url=${SPRING_DATASOURCE_URL}
 3 | spring.datasource.username=${SPRING_DATASOURCE_USERNAME}
 4 | spring.datasource.password=${SPRING_DATASOURCE_PASSWORD}
 5 | 
 6 | # jpa settings
 7 | spring.jpa.hibernate.ddl-auto=${SPRING_JPA_HIBERNATE_DDL_AUTO}
 8 | spring.jpa.database-platform=${SPRING_JPA_DATABASE_PLATFORM}
 9 | 
10 | # bot credentials
11 | bot.username=${BOT_USERNAME}
12 | bot.token=${BOT_TOKEN}
13 | 
14 | # some custom settings:
15 | 
16 | # admin telegram usernames comma separated, example: vasya,alyosha
17 | bot.admin-usernames=${BOT_ADMIN_USERNAME}
18 | # default time from which user can book something
19 | bot.default-start-time=${BOT_DEFAULT_START_TIME}
20 | # default time to which user can book something
21 | bot.default-end-time=${BOT_DEFAULT_END_TIME}
22 | # directory to save booking objects' images
23 | bot.images-dir=${BOT_IMAGES_DIR}
24 | 


--------------------------------------------------------------------------------