FreelanceBot

1
package telegramBot.service;
2

3
import org.springframework.stereotype.Service;
4
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
5
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
6
import org.telegram.telegrambots.meta.api.objects.Update;
7
import telegramBot.dto.OrderDto;
8
import telegramBot.bot.TelegramBot;
9
import org.springframework.context.annotation.Lazy;
10
import org.springframework.stereotype.Component;
11
import telegramBot.entity.Order;
12
import telegramBot.enums.Exchange;
13
import telegramBot.enums.Language;
14
import telegramBot.repository.OrderRepository;
15
import telegramBot.util.BotUtil;
16
import telegramBot.util.OrderUtil;
17

18
import java.util.*;
19
import java.util.stream.Collectors;
20

21

22
@Service
23
public class MessageService {
24

25
    private final TelegramBot bot;
26

27
    public MessageService(@Lazy TelegramBot bot){
28
        this.bot = bot;
29
    }
30

31
    public void sendResponse(String userChatId, String message) {
32
        executeMessage(userChatId, message);
33
    }
34

35
    public void sendNotice(String userChatId, List<OrderDto> dtos) {
36
        executeMessage(userChatId, createNotices(dtos));
37
    }
38

39

40
    private String createNotices(List<OrderDto> orderDtos) {
41
        StringBuilder notice = new StringBuilder();
42
        Map<Exchange, List<OrderDto>> exchangesDtos = sortByExchange(orderDtos);
43
        List<StringBuilder> notices = new ArrayList<>();
44
        StringBuilder output = new StringBuilder();
45
        for(Exchange exchange : Exchange.getExchanges()){
46
            if(!exchangesDtos.containsKey(exchange)){ continue; }
47
            List<OrderDto> eDtos = exchangesDtos.get(exchange);
48
            String title = "Новые заказы на  " + exchange.getName() + ":";
49
            notice.append(title).append("\n");
50
            Map<Language, List<OrderDto>> languagesDtos = sortByLanguage(eDtos);
51
            for(Language language : Language.getLanguages()){
52
                if(!languagesDtos.containsKey(language)){ continue; }
53
                    List<OrderDto> lDtos = languagesDtos.get(language);
54
                    String subscription = "По запросу  " + language.getName() + ":";
55
                    notice.append("\n").append(subscription).append("\n").append(delim());
56
                    for(OrderDto orderDto : lDtos){
57
                        String orderInfo = orderDto.getOrderInfo();
58
                        notice.append("\n")
59
                                .append(orderInfo)
60
                                .append("\n")
61
                                .append(delim())
62
                                .append("\n");
63
                    }
64
            }
65
        }
66
        notices.add(notice);
67

68
        for(StringBuilder n : notices){
69
            output.append(n).append("\n");
70
        }
71

72
    return output.toString();
73

74
    }
75

76
    private Map<Exchange, List<OrderDto>> sortByExchange(List<OrderDto> orderDtos){
77
        Map<Exchange, List<OrderDto>> result = new HashMap<>();
78
        for(Exchange e : Exchange.getExchanges()){
79
            List<OrderDto> dtos = orderDtos.stream()
80
                    .filter((o) -> o.getExchangeName().equals(e.getName()))
81
                    .collect(Collectors.toList());
82

83
            if(!dtos.isEmpty()) {
84
                result.put(e, dtos);
85
            }
86
        }
87

88
        return result;
89
    }
90

91
    private Map<Language, List<OrderDto>> sortByLanguage(List<OrderDto> orderDtos){
92
        Map<Language, List<OrderDto>> result = new HashMap<>();
93
        for(Language l : Language.getLanguages()){
94
            List<OrderDto> dtos = orderDtos.stream()
95
                    .filter((o) -> o.getSubscription().equals(l.getName()))
96
                    .collect(Collectors.toList());
97

98
            if(!dtos.isEmpty()) {
99
                result.put(l, dtos);
100
            }
101
        }
102
        return result;
103
    }
104

105

106
    public static String delim() {
107
        return ".".repeat(70);
108
    }
109

110
    private String trimImgTag(String message){
111
        return message.replaceAll("(<img>)", "");
112
    }
113

114
    private SendMessage buildMessage(String chatId, String content){
115
        org.telegram.telegrambots.meta.api.methods.send.SendMessage sendMessage =
116
                new org.telegram.telegrambots.meta.api.methods.send.SendMessage();
117
        sendMessage.setChatId(chatId);
118
        sendMessage.enableHtml(true);
119
        sendMessage.setText(trimImgTag(content));
120
        sendMessage.disableWebPagePreview();
121
    return sendMessage;
122
    }
123

124

125
    private void executeMessage(String userChatId, String message){
126
        try {
127
            bot.execute(buildMessage(userChatId, message));
128
        } catch (Exception e) {
129
            System.out.println(e.getCause().getMessage());
130
        }
131
    }
132

133
    public String getLatestOrdersMessage(Update update, OrderService service) {
134
        String input = update.getMessage().getText().
135
                replaceAll("\\s", "");
136
        String[] items = extractItems(input);
137
        Language language = Language.ignoreCaseValueOf(items[0]);
138
        int count = Integer.parseInt(items[1]);
139
        List<Order> orders = service.getAllByLanguage(language);
140
        List<OrderDto> dtos = OrderUtil.toDtos(orders).subList(0,
141
                getEndIndex(orders.size(), count));
142
        assert language != null;
143
        return createMessage(language, dtos);
144
    }
145

146
    private String createMessage(Language language, List<OrderDto> dtos){
147
        StringBuilder sb = new StringBuilder("Последние заказы по запросу " +
148
                language.getName() + ":\n" );
149
        dtos.forEach(o -> {
150
            sb.append(o.getOrderInfo()).append(" (").
151
                    append(o.getExchangeName()).
152
                    append(")").append("\n\n");
153
        });
154

155
        return sb.toString();
156
    }
157

158
    private int getEndIndex(int collectionSize, int count){
159
        return Math.min(collectionSize, count);
160
    }
161

162
    private String[] extractItems(String input){
163
        String[] items = input.split(",");
164
        String language = items[0];
165
        String count = (items[1].
166
                matches("\\d+") &&
167
                !items[1].equals("0")) ? items[1] : "1" ;
168
        return new String[]{language, count};
169
    }
170

171
}
172