FreelanceBot

1
package telegramBot.service;
2

3
import org.springframework.boot.CommandLineRunner;
4
import org.springframework.context.annotation.Lazy;
5
import org.springframework.stereotype.Service;
6
import telegramBot.entity.Exchange;
7
import telegramBot.entity.Order;
8
import telegramBot.entity.Subscription;
9
import telegramBot.enums.BotStatus;
10
import telegramBot.enums.Language;
11
import telegramBot.enums.SubscriptionStatus;
12
import telegramBot.repository.ExchangeRepository;
13
import org.springframework.beans.factory.annotation.Autowired;
14
import telegramBot.task.ExchangeParser;
15

16
import java.util.*;
17

18
@Service
19
public class ExchangeService implements CommandLineRunner {
20

21
    @Autowired
22
    private ExchangeRepository exchangeRepository;
23

24
    @Autowired
25
    private SubscriptionService subscriptionService;
26

27
    @Autowired
28
    private @Lazy BotService botService;
29

30
    @Autowired
31
    private OrderService orderService;
32

33
    @Autowired
34
    private ExchangeParser parser;
35

36
    public Exchange get(telegramBot.enums.Exchange exchange) {
37
        return this.exchangeRepository.getByName(exchange.getName());
38
    }
39

40
    public void init() {
41
        List<Subscription> subscriptions = subscriptionService.getAllByStatus(SubscriptionStatus.CREATE);
42
        telegramBot.enums.Exchange[] exchanges = telegramBot.enums.Exchange.getExchanges();
43
        for (Subscription subscription : subscriptions) {
44
            Language language = Language.ignoreCaseValueOf(subscription.getLanguage());
45
            Map<telegramBot.enums.Exchange, List<Order>> exchangesOrders = this.parser.getOrders(language);
46
            for (telegramBot.enums.Exchange e : exchanges) {
47
                List<Order> orders = exchangesOrders.get(e);
48
                telegramBot.entity.Exchange exchange = get(e);
49
                for (Order order : orders) {
50
                    if (orderService.saveIfNotExist(order)) {
51
                        order.setExchange(exchange);
52
                        order.setSubscription(subscription);
53
                        this.orderService.update(order);
54
                    }
55
                }
56
            }
57
            subscription.setStatus(SubscriptionStatus.INIT);
58
            subscriptionService.update(subscription);
59
        }
60
    }
61

62

63
    public void update(Exchange exchange) {
64
        this.exchangeRepository.save(exchange);
65
    }
66

67
    @Override
68
    public void run(String... args) throws Exception {
69
        new Thread(this::init).start();
70
    }
71

72
    public List<Order> findNewOrders(Language language) {
73
        List<Order> newOrders = new ArrayList<>();
74
        telegramBot.enums.Exchange[] exchanges = telegramBot.enums.Exchange.getExchanges();
75
        Map<telegramBot.enums.Exchange, List<Order>> taskOrders = this.parser.getOrders(language);
76
        for (telegramBot.enums.Exchange e : exchanges) {
77
            List<Order> ordersByExchange = taskOrders.get(e);
78
            for (Order order : ordersByExchange) {
79
                if (!this.orderService.exist(order)) {
80
                    Exchange exchange = this.exchangeRepository.getByName(e.getName());
81
                    Subscription subscription = this.subscriptionService.getByLanguage(language);
82

83
                    order.setExchange(exchange);
84
                    order.setSubscription(subscription);
85
                    newOrders.add(order);
86

87
                }
88
            }
89

90
        }
91
        return newOrders;
92
    }
93

94

95

96

97

98
}
99