patrick/Kleinanzeigen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: patrick:b3236bb931e037ab5ed2f37f7900345dc13df7ae
Branches Tags
patrick:globalkeyboard
..
compare: patrick:038b0b76c92f94ac506235fcc94b97b17452b80b
Branches Tags
patrick:globalkeyboard

No commits in common. "b3236bb931e037ab5ed2f37f7900345dc13df7ae" and "038b0b76c92f94ac506235fcc94b97b17452b80b" have entirely different histories.
b3236bb931 ... 038b0b76c9

34 changed files with 303 additions and 863 deletions
Show Stats Expand all files Collapse all files

1
pom.xml
View File

@ -11,7 +11,6 @@
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<maven.compiler.release>21</maven.compiler.release>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

5
src/main/java/de/ph87/kleinanzeigen/crud/CrudAction.java
View File

@ -1,5 +0,0 @@
package de.ph87.kleinanzeigen.crud;
public enum CrudAction {
CREATED, CHANGED, REMOVED
}

75
src/main/java/de/ph87/kleinanzeigen/crud/CrudFilter.java
View File

@ -1,75 +0,0 @@
package de.ph87.kleinanzeigen.crud;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import lombok.Data;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import java.util.Collections;
import java.util.List;
@Getter
@ToString
public class CrudFilter<T> {
protected final int page;
protected final int size;
@NonNull
protected final List<Order> orders;
public CrudFilter(final int page, final int size, @NonNull final List<Order> orders) {
this.page = page;
this.size = size;
this.orders = orders;
}
@NonNull
public Pageable getPageable() {
return PageRequest.of(page, size, getSort());
}
@NonNull
private Sort getSort() {
return Sort.by(orders.stream().map(Order::toOrder).toList());
}
@NonNull
public Specification<T> getSpecification() {
return (root, query, criteriaBuilder) -> {
final List<Predicate> predicates = getPredicates(root, query, criteriaBuilder);
return criteriaBuilder.and(predicates.toArray(Predicate[]::new));
};
}
@NonNull
protected List<Predicate> getPredicates(@NonNull final Root<T> root, final CriteriaQuery<?> query, @NonNull final CriteriaBuilder criteriaBuilder) {
return Collections.emptyList();
}
@Data
public static class Order {
@NonNull
private final String property;
@NonNull
private final Sort.Direction direction;
@NonNull
public Sort.Order toOrder() {
return new Sort.Order(direction, property);
}
}
}

57
src/main/java/de/ph87/kleinanzeigen/crud/CrudFilterSearch.java
View File

@ -1,57 +0,0 @@
package de.ph87.kleinanzeigen.crud;
import jakarta.persistence.criteria.*;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
@Getter
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public abstract class CrudFilterSearch<T> extends CrudFilter<T> {
@NonNull
protected final String search;
protected CrudFilterSearch(final int page, final int size, @NonNull final List<Order> orders, @NonNull final String search) {
super(page, size, orders);
this.search = search;
}
@NonNull
protected List<Predicate> getPredicates(@NonNull final Root<T> root, final CriteriaQuery<?> query, @NonNull final CriteriaBuilder criteriaBuilder) {
return new ArrayList<>(search(root, criteriaBuilder));
}
@NonNull
public List<Predicate> search(@NonNull final Root<T> root, @NonNull final CriteriaBuilder criteriaBuilder) {
final String[] words = search.replaceAll("([0-9])([a-zA-Z])", "$1 $2")
.replaceAll("([a-zA-Z])([0-9])", "$1 $2")
.replaceAll("([a-z])([A-Z])", "$1 $2")
.replaceAll("^\\W+|\\W+$", "")
.toLowerCase(Locale.ROOT)
.split("\\W+");
final List<Path<String>> fields = getFields(root);
return predicateAllWordsEachInAnyField(criteriaBuilder, words, fields);
}
@NonNull
private List<Predicate> predicateAllWordsEachInAnyField(@NonNull final CriteriaBuilder criteriaBuilder, @NonNull final String[] words, @NonNull final List<Path<String>> fields) {
return Arrays.stream(words).map(word -> predicateWordInAnyField(criteriaBuilder, word, fields)).toList();
}
@NonNull
private Predicate predicateWordInAnyField(@NonNull final CriteriaBuilder criteriaBuilder, @NonNull final String word, @NonNull final List<Path<String>> fields) {
return fields.stream().map(field -> criteriaBuilder.like(field, "%" + word + "%")).reduce(criteriaBuilder::or).orElseThrow();
}
@NonNull
protected abstract List<Path<String>> getFields(@NonNull final Root<T> root);
}

27
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/blacklist/Blacklist.java
View File

@ -4,20 +4,22 @@ import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import lombok.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.ToString;
import java.util.regex.Pattern;
import java.util.Arrays;
import java.util.Locale;
@Entity
@Getter
@Setter
@ToString
@NoArgsConstructor
public class Blacklist {
@Id
@GeneratedValue
@Setter(AccessLevel.NONE)
private long id;
@Column(nullable = false)
@ -25,15 +27,26 @@ public class Blacklist {
@NonNull
@Column(nullable = false)
private String regex;
private String query;
public Blacklist(final BlacklistCreate create) {
enabled = create.isEnabled();
regex = create.getQuery();
query = create.getQuery();
}
public void edit(final BlacklistDto edit) {
enabled = edit.isEnabled();
query = edit.getQuery();
}
public boolean matches(@NonNull final String title) {
return Pattern.compile(regex, Pattern.CASE_INSENSITIVE).matcher(title).find();
final String[] words = query.replaceAll("([0-9])([a-zA-Z])", "$1 $2")
.replaceAll("([a-zA-Z])([0-9])", "$1 $2")
.replaceAll("([a-z])([A-Z])", "$1 $2")
.replaceAll("^\\W+|\\W+$", "")
.toLowerCase(Locale.ROOT)
.split("\\W+");
return Arrays.stream(words).map(".*%s.*"::formatted).allMatch(title::matches);
}
}

29
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/blacklist/BlacklistController.java
View File

@ -1,10 +1,10 @@
package de.ph87.kleinanzeigen.kleinanzeigen.blacklist;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@ -13,29 +13,14 @@ public class BlacklistController {
private final BlacklistService blacklistService;
@PostMapping("all")
public List<BlacklistDto> all() {
return blacklistService.all();
}
@PostMapping("create")
public BlacklistDto create(@RequestBody BlacklistCreate create) {
return blacklistService.create(create);
}
@PostMapping("{id}/delete")
public BlacklistDto delete(@PathVariable final long id) {
return blacklistService.delete(id);
}
@PostMapping("{id}/enabled")
public BlacklistDto enabled(@PathVariable final long id, @RequestBody final boolean enabled) {
return blacklistService.enabled(id, enabled);
}
@PostMapping("{id}/query")
public BlacklistDto query(@PathVariable final long id, @NonNull @RequestBody final String query) {
return blacklistService.query(id, query);
@PostMapping("edit")
public BlacklistDto edit(@RequestBody BlacklistDto edit) {
return blacklistService.edit(edit);
}
}

2
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/blacklist/BlacklistDto.java
View File

@ -16,7 +16,7 @@ public class BlacklistDto {
public BlacklistDto(final Blacklist blacklist) {
this.id = blacklist.getId();
this.enabled = blacklist.isEnabled();
this.query = blacklist.getRegex();
this.query = blacklist.getQuery();
}
}

68
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/blacklist/BlacklistService.java
View File

@ -1,17 +1,14 @@
package de.ph87.kleinanzeigen.kleinanzeigen.blacklist;
import de.ph87.kleinanzeigen.crud.CrudAction;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.server.ResponseStatusException;
import java.util.List;
import java.util.function.Consumer;
@Slf4j
@Service
@ -21,51 +18,26 @@ public class BlacklistService {
private final BlacklistRepository blacklistRepository;
private BlacklistDto toDto(Blacklist blacklist) {
return new BlacklistDto(blacklist);
}
public BlacklistDto create(final BlacklistCreate create) {
final BlacklistDto dto = toDto(blacklistRepository.save(new Blacklist(create)));
log.info("Blacklist CREATED: {}", dto);
return dto;
}
public BlacklistDto edit(final BlacklistDto edit) {
final Blacklist blacklist = blacklistRepository.findById(edit.getId()).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
blacklist.edit(edit);
final BlacklistDto dto = toDto(blacklist);
log.info("Blacklist EDITED: {}", dto);
return dto;
}
public List<BlacklistDto> findAllBlacklisted(@NonNull final String title) {
return blacklistRepository.findAllByEnabledTrue().stream().filter(blacklist -> blacklist.matches(title)).map(BlacklistDto::new).toList();
}
public List<BlacklistDto> all() {
return blacklistRepository.findAll().stream().map(BlacklistDto::new).toList();
}
public BlacklistDto create(final BlacklistCreate create) {
final Blacklist blacklist = blacklistRepository.save(new Blacklist(create));
return publish(blacklist, CrudAction.CREATED);
}
@NonNull
public BlacklistDto delete(final long id) {
final Blacklist blacklist = getById(id);
return publish(blacklist, CrudAction.REMOVED);
}
@PostMapping("{id}/enabled")
public BlacklistDto enabled(@PathVariable final long id, @RequestBody final boolean enabled) {
return set(id, blacklist -> blacklist.setEnabled(enabled));
}
@PostMapping("{id}/query")
public BlacklistDto query(@PathVariable final long id, @NonNull @RequestBody final String query) {
return set(id, blacklist -> blacklist.setRegex(query));
}
@NonNull
public BlacklistDto set(final long id, @NonNull final Consumer<Blacklist> setter) {
final Blacklist blacklist = getById(id);
setter.accept(blacklist);
return publish(blacklist, CrudAction.CHANGED);
}
@NonNull
private Blacklist getById(final long id) {
return blacklistRepository.findById(id).orElseThrow();
}
private BlacklistDto publish(@NonNull final Blacklist blacklist, @NonNull final CrudAction action) {
final BlacklistDto dto = new BlacklistDto(blacklist);
log.info("Blacklist {}: {}", action, dto);
return dto;
}
}

24
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/offer/OfferController.java
View File

@ -1,24 +0,0 @@
package de.ph87.kleinanzeigen.kleinanzeigen.offer;
import jakarta.annotation.Nullable;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.*;
@CrossOrigin
@RestController
@RequiredArgsConstructor
@RequestMapping("Offer")
public class OfferController {
private final OfferService offerService;
@GetMapping("filter")
public Page<OfferDto> getAllOffers(@Nullable @RequestBody(required = false) final OfferFilter filter) {
if (filter == null) {
return offerService.filter(OfferFilter.DEFAULT());
}
return offerService.filter(filter);
}
}

2
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/offer/OfferCreate.java
View File

@ -65,7 +65,7 @@ public class OfferCreate {
articleDate = parseDate(article.select(".aditem-main--top--right").text());
articleURL = uri.resolve(article.select(".aditem-image a").attr("href")).toString();
final String locationString = article.select(".aditem-main--top--left").text();
final Matcher locationMatcher = Pattern.compile("^(?<zipcode>\\d+) (?<location>.+) \\((:?ca.)?\\s*(?<distance>\\d+(?:[,.]\\d+)?)\\s*(?:km)?\\s*\\)$").matcher(locationString);
final Matcher locationMatcher = Pattern.compile("^(?<zipcode>\\d+) (?<location>.+) \\((:?ca.)?\\s*(?<distance>\\d+(?:[,.]\\d+)?)\\s*km\\s*\\)$").matcher(locationString);
if (!locationMatcher.find()) {
throw new LocationNotFound();
}

30
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/offer/OfferFilter.java
View File

@ -1,30 +0,0 @@
package de.ph87.kleinanzeigen.kleinanzeigen.offer;
import de.ph87.kleinanzeigen.crud.CrudFilterSearch;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Root;
import lombok.Getter;
import lombok.NonNull;
import lombok.ToString;
import org.springframework.data.domain.Sort;
import java.util.List;
@Getter
@ToString(callSuper = true)
public class OfferFilter extends CrudFilterSearch<Offer> {
public OfferFilter(final int page, final int size, @NonNull final List<Order> orders, @NonNull final String search) {
super(page, size, orders, search);
}
@Override
protected @NonNull List<Path<String>> getFields(final @NonNull Root<Offer> root) {
return List.of(root.get("title"), root.get("description"));
}
public static OfferFilter DEFAULT() {
return new OfferFilter(0, 30, List.of(new Order("articleDate", Sort.Direction.DESC)), "");
}
}

3
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/offer/OfferRepository.java
View File

@ -1,11 +1,10 @@
package de.ph87.kleinanzeigen.kleinanzeigen.offer;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.ListCrudRepository;
import java.util.Optional;
public interface OfferRepository extends ListCrudRepository<Offer, Long>, JpaSpecificationExecutor<Offer> {
public interface OfferRepository extends ListCrudRepository<Offer, Long> {
Optional<Offer> findByArticleId(String articleId);

25
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/offer/OfferService.java
View File

@ -4,7 +4,6 @@ import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -19,16 +18,19 @@ public class OfferService {
private final ApplicationEventPublisher publisher;
public void updateOrCreate(@NonNull final OfferCreate create, final boolean resendOnPriceChange) {
offerRepository.findByArticleId(create.getArticleId()).ifPresentOrElse(existing -> {
if (existing.update(create, resendOnPriceChange)) {
final OfferDto dto = toDto(existing);
offerRepository.findByArticleId(create.getArticleId()).ifPresentOrElse(
existing -> {
if (existing.update(create, resendOnPriceChange)) {
final OfferDto dto = toDto(existing);
publisher.publishEvent(dto);
}
},
() -> {
final Offer offer = offerRepository.save(new Offer(create, resendOnPriceChange));
final OfferDto dto = toDto(offer);
publisher.publishEvent(dto);
}
}, () -> {
final Offer offer = offerRepository.save(new Offer(create, resendOnPriceChange));
final OfferDto dto = toDto(offer);
publisher.publishEvent(dto);
});
);
}
public OfferDto toDto(final Offer offer) {
@ -39,9 +41,4 @@ public class OfferService {
return offerRepository.findById(offerDto.getId()).orElseThrow();
}
@NonNull
public Page<OfferDto> filter(@NonNull final OfferFilter filter) {
return offerRepository.findAll(filter.getSpecification(), filter.getPageable()).map(OfferDto::new);
}
}

15
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/search/Search.java
View File

@ -5,18 +5,19 @@ import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import lombok.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.ToString;
@Entity
@Getter
@Setter
@ToString
@NoArgsConstructor
public class Search {
@Id
@GeneratedValue
@Setter(AccessLevel.NONE)
private long id;
@Column(nullable = false)
@ -48,4 +49,12 @@ public class Search {
priceMax = create.getPriceMax();
}
public void edit(final SearchDto edit) {
enabled = edit.isEnabled();
query = edit.getQuery();
radius = edit.getRadius();
priceMin = edit.getPriceMin();
priceMax = edit.getPriceMax();
}
}

50
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/search/SearchController.java
View File

@ -1,11 +1,10 @@
package de.ph87.kleinanzeigen.kleinanzeigen.search;
import jakarta.annotation.Nullable;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@ -14,49 +13,14 @@ public class SearchController {
private final SearchService searchService;
@PostMapping("all")
public List<SearchDto> all() {
return searchService.all();
}
@PostMapping("create")
public SearchDto create(@RequestBody SearchCreate create) {
return searchService.create(create);
}
@PostMapping("{id}/delete")
public SearchDto delete(@PathVariable final long id) {
return searchService.delete(id);
}
@PostMapping("{id}/enabled")
public SearchDto enabled(@PathVariable final long id, @RequestBody final boolean enabled) {
return searchService.enabled(id, enabled);
}
@PostMapping("{id}/query")
public SearchDto query(@PathVariable final long id, @NonNull @RequestBody final String query) {
return searchService.query(id, query);
}
@PostMapping("{id}/radius")
public SearchDto radius(@PathVariable final long id, @RequestBody final int radius) {
return searchService.radius(id, radius);
}
@PostMapping("{id}/priceMin")
public SearchDto priceMin(@PathVariable final long id, @Nullable @RequestBody(required = false) final Integer priceMin) {
return searchService.priceMin(id, priceMin);
}
@PostMapping("{id}/priceMax")
public SearchDto priceMax(@PathVariable final long id, @Nullable @RequestBody(required = false) final Integer priceMax) {
return searchService.priceMax(id, priceMax);
}
@PostMapping("{id}/resendOnPriceChange")
public SearchDto resendOnPriceChange(@PathVariable final long id, @RequestBody final boolean resendOnPriceChange) {
return searchService.resendOnPriceChange(id, resendOnPriceChange);
@PostMapping("edit")
public SearchDto edit(@RequestBody SearchDto edit) {
return searchService.edit(edit);
}
}

76
src/main/java/de/ph87/kleinanzeigen/kleinanzeigen/search/SearchService.java
View File

@ -1,18 +1,13 @@
package de.ph87.kleinanzeigen.kleinanzeigen.search;
import de.ph87.kleinanzeigen.crud.CrudAction;
import jakarta.annotation.Nullable;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.server.ResponseStatusException;
import java.util.List;
import java.util.function.Consumer;
@Slf4j
@Service
@ -23,69 +18,24 @@ public class SearchService {
private final SearchRepository searchRepository;
public List<SearchDto> findAllEnabledDto() {
return searchRepository.findAllByEnabledTrue().stream().map(SearchDto::new).toList();
return searchRepository.findAllByEnabledTrue().stream().map(this::toDto).toList();
}
public List<SearchDto> all() {
return searchRepository.findAll().stream().map(SearchDto::new).toList();
private SearchDto toDto(Search search) {
return new SearchDto(search);
}
public SearchDto create(final SearchCreate create) {
final Search search = searchRepository.save(new Search(create));
return publish(search, CrudAction.CREATED);
final SearchDto dto = toDto(searchRepository.save(new Search(create)));
log.info("Search CREATED: {}", dto);
return dto;
}
@NonNull
public SearchDto delete(final long id) {
final Search search = getById(id);
return publish(search, CrudAction.REMOVED);
}
@PostMapping("{id}/enabled")
public SearchDto enabled(@PathVariable final long id, @RequestBody final boolean enabled) {
return set(id, search -> search.setEnabled(enabled));
}
@PostMapping("{id}/query")
public SearchDto query(@PathVariable final long id, @NonNull @RequestBody final String query) {
return set(id, search -> search.setQuery(query));
}
@PostMapping("{id}/radius")
public SearchDto radius(@PathVariable final long id, @RequestBody final int radius) {
return set(id, search -> search.setRadius(radius));
}
@PostMapping("{id}/priceMin")
public SearchDto priceMin(@PathVariable final long id, @Nullable @RequestBody(required = false) final Integer priceMin) {
return set(id, search -> search.setPriceMin(priceMin));
}
@PostMapping("{id}/priceMax")
public SearchDto priceMax(@PathVariable final long id, @Nullable @RequestBody(required = false) final Integer priceMax) {
return set(id, search -> search.setPriceMax(priceMax));
}
@PostMapping("{id}/resendOnPriceChange")
public SearchDto resendOnPriceChange(@PathVariable final long id, @RequestBody final boolean resendOnPriceChange) {
return set(id, search -> search.setResendOnPriceChange(resendOnPriceChange));
}
@NonNull
public SearchDto set(final long id, @NonNull final Consumer<Search> setter) {
final Search search = getById(id);
setter.accept(search);
return publish(search, CrudAction.CHANGED);
}
@NonNull
private Search getById(final long id) {
return searchRepository.findById(id).orElseThrow();
}
private SearchDto publish(@NonNull final Search search, @NonNull final CrudAction action) {
final SearchDto dto = new SearchDto(search);
log.info("Search {}: {}", action, dto);
public SearchDto edit(final SearchDto edit) {
final Search search = searchRepository.findById(edit.getId()).orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST));
search.edit(edit);
final SearchDto dto = toDto(search);
log.info("Search EDITED: {}", dto);
return dto;
}

5
src/main/java/de/ph87/kleinanzeigen/telegram/AccessDenied.java Normal file
View File

@ -0,0 +1,5 @@
package de.ph87.kleinanzeigen.telegram;
public class AccessDenied extends Exception {
}

2
src/main/java/de/ph87/kleinanzeigen/telegram/InlineCommand.java
View File

@ -1,5 +1,5 @@
package de.ph87.kleinanzeigen.telegram;
public enum InlineCommand {
HIDE, REMEMBER, UNREMEMBER, UNDO
HIDE, REMEMBER, UNREMEMBER
}

101
src/main/java/de/ph87/kleinanzeigen/telegram/TelegramBot.java
View File

@ -1,115 +1,44 @@
package de.ph87.kleinanzeigen.telegram;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import de.ph87.kleinanzeigen.telegram.request.ChatRequestEnable;
import de.ph87.kleinanzeigen.telegram.request.ChatRequestHelp;
import de.ph87.kleinanzeigen.telegram.request.ChatRequestUndo;
import de.ph87.kleinanzeigen.telegram.request.MessageRequestHide;
import de.ph87.kleinanzeigen.telegram.request.MessageRequestRemember;
import jakarta.annotation.PreDestroy;
import lombok.NonNull;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.TelegramBotsApi;
import org.telegram.telegrambots.meta.api.methods.updatingmessages.DeleteMessage;
import org.telegram.telegrambots.meta.api.objects.CallbackQuery;
import org.telegram.telegrambots.meta.api.objects.MaybeInaccessibleMessage;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
import java.util.Locale;
import java.io.IOException;
import java.util.function.Consumer;
@Slf4j
@Service
public class TelegramBot extends TelegramLongPollingBot {
private final TelegramConfig config;
private final ObjectMapper objectMapper;
private final ApplicationEventPublisher publisher;
private final DefaultBotSession session;
public TelegramBot(final TelegramConfig config, final ObjectMapper objectMapper, final ApplicationEventPublisher publisher) throws TelegramApiException {
super(config.getToken());
private final Consumer<Update> onUpdate;
this.config = config;
this.publisher = publisher;
@Getter
private final String botUsername;
public TelegramBot(final String token, final String username, final Consumer<Update> onUpdate) throws IOException, TelegramApiException {
super(token);
this.botUsername = username;
this.onUpdate = onUpdate;
getOptions().setGetUpdatesTimeout(10);
log.info("Starting telegram bot...");
final TelegramBotsApi api = new TelegramBotsApi(DefaultBotSession.class);
session = (DefaultBotSession) api.registerBot(this);
log.info("Telegram bot registered.");
this.objectMapper = objectMapper;
}
@PreDestroy
@Override
public void onUpdateReceived(final Update update) {
onUpdate.accept(update);
}
public void stop() {
log.info("Stopping Telegram bot...");
session.stop();
log.info("Telegram bot stopped");
}
@Override
public String getBotUsername() {
return config.getUsername();
}
@Override
public void onUpdateReceived(@NonNull final Update update) {
if (update.hasMessage() && update.getMessage().hasText()) {
handleMessage(update.getMessage());
} else if (update.hasCallbackQuery()) {
handleCallback(update.getCallbackQuery());
}
}
private void handleMessage(@NonNull final Message message) {
final String[] command = message.getText().toLowerCase(Locale.ROOT).replaceAll("[^\\w\\s]+", "").replaceAll("\\s+", " ").split(" ");
switch (command[0]) {
case "start" -> publisher.publishEvent(new ChatRequestEnable(this, message, true));
case "stop" -> publisher.publishEvent(new ChatRequestEnable(this, message, false));
case "u", "r", "undo", "rückgängig" -> publisher.publishEvent(new ChatRequestUndo(this, message));
case "h", "hilfe", "help" -> publisher.publishEvent(new ChatRequestHelp(this, message));
}
delete(new TlgMessage(this, message));
}
private void handleCallback(@NonNull final CallbackQuery callback) {
final MaybeInaccessibleMessage message = callback.getMessage();
try {
final InlineDto dto = objectMapper.readValue(callback.getData(), InlineDto.class);
switch (dto.getCommand()) {
case HIDE -> hide(message);
case REMEMBER -> publisher.publishEvent(new MessageRequestRemember(this, message, true));
case UNREMEMBER -> publisher.publishEvent(new MessageRequestRemember(this, message, false));
case UNDO -> publisher.publishEvent(new ChatRequestUndo(this, message));
}
} catch (JsonProcessingException e) {
log.error("Failed to read InlineDto.", e);
}
}
private void hide(final MaybeInaccessibleMessage message) {
final MessageRequestHide event = new MessageRequestHide(this, message);
delete(event);
publisher.publishEvent(event);
}
public void delete(@NonNull final TlgMessage tlgMessage) {
try {
log.info("Removing TlgMessage: tlgMessage={}", tlgMessage);
execute(new DeleteMessage(tlgMessage.chat.idStr, tlgMessage.id));
} catch (TelegramApiException e) {
log.error("Failed to remove TlgMessage: tlgMessage={}", tlgMessage);
}
}
}

199
src/main/java/de/ph87/kleinanzeigen/telegram/TelegramAdapter.java → src/main/java/de/ph87/kleinanzeigen/telegram/TelegramService.java
View File

@ -5,27 +5,20 @@ import com.fasterxml.jackson.databind.ObjectMapper;
import de.ph87.kleinanzeigen.kleinanzeigen.offer.OfferDto;
import de.ph87.kleinanzeigen.telegram.chat.ChatDto;
import de.ph87.kleinanzeigen.telegram.chat.ChatService;
import de.ph87.kleinanzeigen.telegram.chat.message.MessageDeleted;
import de.ph87.kleinanzeigen.telegram.chat.message.MessageDto;
import de.ph87.kleinanzeigen.telegram.chat.message.MessageService;
import de.ph87.kleinanzeigen.telegram.request.ChatRequestEnable;
import de.ph87.kleinanzeigen.telegram.request.ChatRequestHelp;
import de.ph87.kleinanzeigen.telegram.request.ChatRequestUndo;
import de.ph87.kleinanzeigen.telegram.request.MessageRequestHide;
import de.ph87.kleinanzeigen.telegram.request.MessageRequestRemember;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;
import org.springframework.transaction.event.TransactionalEventListener;
import org.telegram.telegrambots.meta.api.methods.send.SendPhoto;
import org.telegram.telegrambots.meta.api.methods.updatingmessages.DeleteMessage;
import org.telegram.telegrambots.meta.api.methods.updatingmessages.EditMessageCaption;
import org.telegram.telegrambots.meta.api.objects.InputFile;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.api.objects.*;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
@ -40,39 +33,37 @@ import java.util.List;
@Slf4j
@Service
@EnableAsync
@RequiredArgsConstructor
public class TelegramAdapter {
private static final String ICON_UNDO = "⎌";
public class TelegramService {
private static final String ICON_CHECK = "✅";
private static final String ICON_REMOVE = "❌";
private final TelegramConfig config;
private final ChatService chatService;
private final MessageService messageService;
private final TelegramBot bot;
private final ObjectMapper objectMapper;
private byte[] NO_IMAGE = null;
private TelegramBot bot = null;
@PostConstruct
public void postConstruct() throws IOException {
final BufferedImage img = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
final ByteArrayOutputStream stream = new ByteArrayOutputStream();
ImageIO.write(img, "PNG", stream);
NO_IMAGE = stream.toByteArray();
}
@PreDestroy
public void stop() {
log.info("Stopping Telegram bot...");
bot.stop();
log.info("Telegram bot stopped");
try {
bot = new TelegramBot(config.getToken(), config.getUsername(), this::onUpdateReceived);
} catch (TelegramApiException | IOException e) {
log.error("Failed to start TelegramBot: {}", e.toString());
}
}
@TransactionalEventListener(OfferDto.class)
@ -84,72 +75,72 @@ public class TelegramAdapter {
.stream()
.filter(m -> m.getChat().getId() == chat.getId())
.findFirst()
.ifPresentOrElse(this::update, () -> send(offer, chat));
.ifPresentOrElse(message -> update(message, false), () -> send(offer, chat));
}
}
@Async
@EventListener(ChatRequestEnable.class)
public void onChatEnable(@NonNull final ChatRequestEnable request) {
chatService.setEnabled(request, request.isEnable(), request.getUsername());
messageService.undo(request);
@TransactionalEventListener(MessageDeleted.class)
public void onMessageDeleted(final MessageDeleted messageDeleted) {
remove(messageDeleted.getChatId(), messageDeleted.getMessageId());
}
@Async
@EventListener(ChatRequestUndo.class)
public void onChatUndo(@NonNull final ChatRequestUndo request) {
messageService.undo(request);
@PreDestroy
public void stop() {
log.info("Stopping Telegram bot...");
bot.stop();
log.info("Telegram bot stopped");
}
@Async
@EventListener(ChatRequestHelp.class)
public void onChatHelp(@NonNull final ChatRequestHelp request) {
chatService.help(request);
}
@Async
@EventListener(MessageRequestHide.class)
public void onMessageHide(@NonNull final MessageRequestHide request) {
messageService.setHide(request);
}
@Async
@EventListener(MessageRequestRemember.class)
public void onMessageRemember(@NonNull final MessageRequestRemember request) {
messageService.setRemember(request, request.isRemember());
}
@TransactionalEventListener(MessageDto.class)
public void update(@NonNull final MessageDto message) {
if (maySend(message)) {
return;
private void onUpdateReceived(@NonNull final Update update) {
try {
if (update.hasMessage() && update.getMessage().hasText()) {
handleMessage(update.getMessage());
} else if (update.hasCallbackQuery()) {
handleCallback(update.getCallbackQuery());
}
} catch (AccessDenied e) {
log.warn("Access denied: {}", update);
}
if (mayDelete(message)) {
return;
}
if (message.getTelegramMessageId() == null) {
return;
}
edit(message);
}
private boolean maySend(final @NonNull MessageDto message) {
if (message.needsToBeSent()) {
send(message.getOffer(), message.getChat());
return true;
private void handleMessage(@NonNull final Message tlgMessage) throws AccessDenied {
switch (tlgMessage.getText()) {
case "/stop" -> chatService.setEnabled(tlgMessage.getChatId(), false, tlgMessage.getFrom().getUserName());
case "undo" -> undo(tlgMessage);
}
return false;
}
private boolean mayDelete(final @NonNull MessageDto message) {
if (message.needsToBeDeleted()) {
TlgMessage.of(bot, message).ifPresent(tlgMessage -> {
bot.delete(tlgMessage);
messageService.markDeleted(tlgMessage);
});
return true;
private void undo(@NonNull final Message tlgMessage) {
messageService.undo(tlgMessage.getChatId()).ifPresent(message -> update(message, true));
remove(tlgMessage);
}
private void handleCallback(@NonNull final CallbackQuery callback) throws AccessDenied {
final MaybeInaccessibleMessage tlgMessage = callback.getMessage();
chatService.setEnabled(tlgMessage.getChatId(), true, callback.getFrom().getUserName());
try {
final InlineDto dto = objectMapper.readValue(callback.getData(), InlineDto.class);
switch (dto.getCommand()) {
case HIDE -> hide(tlgMessage);
case REMEMBER -> remember(tlgMessage, true);
case UNREMEMBER -> remember(tlgMessage, false);
default -> update(tlgMessage);
}
} catch (JsonProcessingException e) {
log.error("Failed to read InlineDto.", e);
}
return false;
}
private void hide(@NonNull final MaybeInaccessibleMessage tlgMessage) {
messageService.setHide(tlgMessage, true).ifPresentOrElse(message -> update(message, false), () -> remove(tlgMessage));
}
private void remember(@NonNull final MaybeInaccessibleMessage tlgMessage, final boolean remember) {
messageService.setRemember(tlgMessage, remember).ifPresentOrElse(message -> update(message, false), () -> remove(tlgMessage));
}
private void update(@NonNull final MaybeInaccessibleMessage tlgMessage) {
messageService.findDtoByTelegramMessage(tlgMessage).ifPresentOrElse(message -> update(message, false), () -> remove(tlgMessage));
}
private void send(@NonNull final OfferDto offerDto, @NonNull final ChatDto chatDto) {
@ -168,7 +159,41 @@ public class TelegramAdapter {
}
}
private void edit(@NonNull final MessageDto message) {
private void update(@NonNull final MessageDto message, final boolean forceResend) {
if (resend(message, forceResend)) {
return;
}
if (deleteFromTelegram(message)) {
return;
}
if (message.getTelegramMessageId() == null) {
return;
}
_update(message);
}
private boolean resend(final MessageDto message, final boolean forceResend) {
final boolean resendOnPriceChange = message.getOffer().isResendOnPriceChange() && message.getOffer().getPriceChanged() != null && message.getHide() != null && !message.getOffer().getPriceChanged().isBefore(message.getHide());
if (forceResend || resendOnPriceChange) {
messageService.setHide(message, false);
if (message.getTelegramMessageId() == null) {
send(message.getOffer(), message.getChat());
return true;
}
}
return false;
}
private boolean deleteFromTelegram(final MessageDto message) {
if (message.getHide() != null && message.getTelegramMessageId() != null) {
remove(message.getChat().getId(), message.getTelegramMessageId());
messageService.clearTelegramMessageId(message);
return true;
}
return false;
}
private void _update(final MessageDto message) {
try {
final EditMessageCaption edit = new EditMessageCaption(
message.getChat().getId() + "",
@ -185,7 +210,7 @@ public class TelegramAdapter {
} catch (TelegramApiException | JsonProcessingException e) {
if (e.toString().endsWith("Bad Request: message to edit not found")) {
log.info("Message has been deleted by User. Marking has hidden: {}", message);
TlgMessage.of(bot, message).ifPresent(messageService::markDeleted);
messageService.setHide(message, true);
} else if (e.toString().endsWith("Bad Request: message is not modified: specified new message content and reply markup are exactly the same as a current content and reply markup of the message")) {
log.debug("Ignoring complaint from telegram-bot-api about unmodified message: {}", message);
} else {
@ -194,8 +219,7 @@ public class TelegramAdapter {
}
}
@NonNull
private String createText(@NonNull final OfferDto offer) {
private String createText(final OfferDto offer) {
return "%s\n%s\n%s %s (%d km)\n%s\n%s\n".formatted(
offer.getTitle().replaceAll("\\[", "(").replaceAll("]", ")"),
offer.combinePrice(),
@ -207,7 +231,6 @@ public class TelegramAdapter {
);
}
@NonNull
private InlineKeyboardMarkup createKeyboard(final boolean remember) throws JsonProcessingException {
final InlineKeyboardMarkup markup = new InlineKeyboardMarkup();
final ArrayList<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
@ -216,17 +239,29 @@ public class TelegramAdapter {
addButton(row, ICON_CHECK + ICON_CHECK + ICON_CHECK + " Gemerkt " + ICON_CHECK + ICON_CHECK + ICON_CHECK, InlineCommand.UNREMEMBER);
} else {
addButton(row, ICON_REMOVE + " Entfernen", InlineCommand.HIDE);
// addButton(row, ICON_CHECK + " Merken", InlineCommand.REMEMBER);
addButton(row, ICON_UNDO + " Rückgängig", InlineCommand.UNDO);
addButton(row, ICON_CHECK + " Merken", InlineCommand.REMEMBER);
}
keyboard.add(row);
markup.setKeyboard(keyboard);
return markup;
}
private void addButton(@NonNull final ArrayList<InlineKeyboardButton> row, @NonNull final String caption, @NonNull final InlineCommand command) throws JsonProcessingException {
private void addButton(final ArrayList<InlineKeyboardButton> row, final String caption, final InlineCommand command) throws JsonProcessingException {
final String data = objectMapper.writeValueAsString(new InlineDto(command));
row.add(new InlineKeyboardButton(caption, null, data, null, null, null, null, null, null));
}
private void remove(final MaybeInaccessibleMessage tlgMessage) {
remove(tlgMessage.getChatId(), tlgMessage.getMessageId());
}
private void remove(final long chatId, final int messageId) {
try {
log.info("Removing Message chat={} message={}", chatId, messageId);
bot.execute(new DeleteMessage(chatId + "", messageId));
} catch (TelegramApiException e) {
log.error("Failed to remove Message chat={} message={}", chatId, messageId);
}
}
}

35
src/main/java/de/ph87/kleinanzeigen/telegram/TlgChat.java
View File

@ -1,35 +0,0 @@
package de.ph87.kleinanzeigen.telegram;
import lombok.NonNull;
import lombok.ToString;
import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
import org.telegram.telegrambots.meta.api.objects.MaybeInaccessibleMessage;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import java.io.Serializable;
@ToString
public class TlgChat {
public final TelegramBot bot;
public final long id;
public final String idStr;
public TlgChat(@NonNull final TelegramBot bot, final long id) {
this.bot = bot;
this.id = id;
this.idStr = this.id + "";
}
public TlgChat(@NonNull final TelegramBot bot, @NonNull final MaybeInaccessibleMessage message) {
this(bot, message.getChatId());
}
@NonNull
public <T extends Serializable, Method extends BotApiMethod<T>> T execute(@NonNull final Method method) throws TelegramApiException {
return bot.execute(method);
}
}

41
src/main/java/de/ph87/kleinanzeigen/telegram/TlgMessage.java
View File

@ -1,41 +0,0 @@
package de.ph87.kleinanzeigen.telegram;
import de.ph87.kleinanzeigen.telegram.chat.message.MessageDto;
import lombok.NonNull;
import lombok.ToString;
import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
import org.telegram.telegrambots.meta.api.objects.MaybeInaccessibleMessage;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import java.io.Serializable;
import java.util.Optional;
@ToString
public class TlgMessage {
public final TlgChat chat;
public final int id;
private TlgMessage(@NonNull final TelegramBot bot, final long chatId, final int id) {
this.chat = new TlgChat(bot, chatId);
this.id = id;
}
public TlgMessage(@NonNull final TelegramBot bot, @NonNull final MaybeInaccessibleMessage message) {
this(bot, message.getChatId(), message.getMessageId());
}
public static Optional<TlgMessage> of(@NonNull final TelegramBot bot, @NonNull final MessageDto message) {
if (message.getTelegramMessageId() == null) {
return Optional.empty();
}
return Optional.of(new TlgMessage(bot, message.getChat().getId(), message.getTelegramMessageId()));
}
@NonNull
public <T extends Serializable, Method extends BotApiMethod<T>> T execute(@NonNull final Method method) throws TelegramApiException {
return chat.bot.execute(method);
}
}

9
src/main/java/de/ph87/kleinanzeigen/telegram/chat/Chat.java
View File

@ -1,7 +1,6 @@
package de.ph87.kleinanzeigen.telegram.chat;
import jakarta.annotation.Nullable;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import lombok.*;
@ -19,14 +18,8 @@ public class Chat {
private boolean enabled;
@Setter
@NonNull
@Column(nullable = false)
private String name;
@Setter
@Column
@Nullable
private Long keyboardMessageId = null;
private String name;
public Chat(final long id, final boolean enabled, @NonNull final String name) {
this.id = id;

5
src/main/java/de/ph87/kleinanzeigen/telegram/chat/ChatDto.java
View File

@ -1,6 +1,5 @@
package de.ph87.kleinanzeigen.telegram.chat;
import jakarta.annotation.Nullable;
import lombok.Data;
@Data
@ -12,14 +11,10 @@ public class ChatDto {
private final String name;
@Nullable
private final Long keyboardMessageId;
public ChatDto(final Chat chat) {
this.id = chat.getId();
this.enabled = chat.isEnabled();
this.name = chat.getName();
this.keyboardMessageId = chat.getKeyboardMessageId();
}
}

63
src/main/java/de/ph87/kleinanzeigen/telegram/chat/ChatService.java
View File

@ -1,18 +1,11 @@
package de.ph87.kleinanzeigen.telegram.chat;
import de.ph87.kleinanzeigen.telegram.AccessDenied;
import de.ph87.kleinanzeigen.telegram.TelegramConfig;
import de.ph87.kleinanzeigen.telegram.TlgChat;
import de.ph87.kleinanzeigen.telegram.request.ChatRequestHelp;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardButton;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardRow;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import java.util.List;
@ -30,48 +23,26 @@ public class ChatService {
return chatRepository.findAllByEnabledTrue().stream().filter(chat -> config.isOnWhitelist(chat.getId())).map(this::toDto).toList();
}
public void setEnabled(@NonNull final TlgChat tlgChat, final boolean enabled, final @NonNull String username) {
if (!config.isOnWhitelist(tlgChat.id)) {
log.warn("Not on whitelist: {}", tlgChat);
return;
public void setEnabled(final long id, final boolean enabled, final String name) throws AccessDenied {
if (!config.isOnWhitelist(id)) {
throw new AccessDenied();
}
chatRepository
.findById(tlgChat.id)
.findById(id)
.stream()
.peek(chat -> update(chat, enabled, username))
.peek(chat -> {
chat.setName(name);
if (chat.isEnabled() != enabled) {
chat.setEnabled(enabled);
log.info("Chat {}: {}", enabled ? "ENABLED" : "DISABLED", chat);
}
})
.findFirst()
.orElseGet(() -> create(tlgChat, enabled, username));
}
@NonNull
private Chat create(@NonNull final TlgChat tlgChat, final boolean enabled, final @NonNull String username) {
final Chat chat = chatRepository.save(new Chat(tlgChat.id, enabled, username));
log.info("Chat created: {}", chat);
return chat;
}
public void help(@NonNull final ChatRequestHelp request) {
final SendMessage send = new SendMessage(request.idStr, "");
final KeyboardRow row0 = new KeyboardRow(List.of(
new KeyboardButton("Rückgängig"),
new KeyboardButton("Alles löschen")
));
final List<KeyboardRow> keyboard = List.of(row0);
send.setReplyMarkup(new ReplyKeyboardMarkup(keyboard));
try {
request.execute(send);
} catch (TelegramApiException e) {
log.error("Failed to printHelp: request={}, error={}", request, e.toString());
}
}
private void update(@NonNull final Chat chat, final boolean enabled, final @NonNull String username) {
chat.setName(username);
if (chat.isEnabled() != enabled) {
chat.setEnabled(enabled);
log.info("Chat {}: {}", enabled ? "ENABLED" : "DISABLED", chat);
}
.orElseGet(() -> {
final Chat chat = chatRepository.save(new Chat(id, enabled, name));
log.info("Chat created: {}", chat);
return chat;
});
}
public Chat getByDto(final ChatDto chatDto) {

16
src/main/java/de/ph87/kleinanzeigen/telegram/chat/message/Message.java
View File

@ -31,6 +31,7 @@ public class Message {
@Nullable
private Integer telegramMessageId;
@Setter
@Column
@Nullable
private ZonedDateTime hide = null;
@ -45,19 +46,4 @@ public class Message {
this.telegramMessageId = tlgMessage.getMessageId();
}
public void setHide(final boolean hide) {
if (hide) {
if (this.hide == null) {
this.hide = ZonedDateTime.now();
}
} else {
this.hide = null;
}
}
@Nullable
public ZonedDateTime getHide() {
return hide;
}
}

17
src/main/java/de/ph87/kleinanzeigen/telegram/chat/message/MessageDeleted.java Normal file
View File

@ -0,0 +1,17 @@
package de.ph87.kleinanzeigen.telegram.chat.message;
import lombok.Data;
@Data
public class MessageDeleted {
private final long chatId;
private final int messageId;
public MessageDeleted(final long chatId, final int messageId) {
this.chatId = chatId;
this.messageId = messageId;
}
}

8
src/main/java/de/ph87/kleinanzeigen/telegram/chat/message/MessageDto.java
View File

@ -36,12 +36,4 @@ public class MessageDto {
remember = message.isRemember();
}
public boolean needsToBeSent() {
return hide == null && telegramMessageId == null;
}
public boolean needsToBeDeleted() {
return hide != null && telegramMessageId != null;
}
}

86
src/main/java/de/ph87/kleinanzeigen/telegram/chat/message/MessageService.java
View File

@ -3,26 +3,26 @@ package de.ph87.kleinanzeigen.telegram.chat.message;
import de.ph87.kleinanzeigen.kleinanzeigen.offer.Offer;
import de.ph87.kleinanzeigen.kleinanzeigen.offer.OfferDto;
import de.ph87.kleinanzeigen.kleinanzeigen.offer.OfferService;
import de.ph87.kleinanzeigen.telegram.TlgChat;
import de.ph87.kleinanzeigen.telegram.TlgMessage;
import de.ph87.kleinanzeigen.telegram.chat.Chat;
import de.ph87.kleinanzeigen.telegram.chat.ChatDto;
import de.ph87.kleinanzeigen.telegram.chat.ChatService;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.telegram.telegrambots.meta.api.objects.MaybeInaccessibleMessage;
import java.time.ZonedDateTime;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
@Slf4j
@Service
@Transactional
@EnableScheduling
@RequiredArgsConstructor
public class MessageService {
@ -32,8 +32,6 @@ public class MessageService {
private final ChatService chatService;
private final ApplicationEventPublisher applicationEventPublisher;
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updateOrCreate(final OfferDto offerDto, final ChatDto chatDto, final org.telegram.telegrambots.meta.api.objects.Message tlgMessage) {
final Offer offer = offerService.getByDto(offerDto);
@ -44,60 +42,48 @@ public class MessageService {
);
}
public void setHide(@NonNull final TlgMessage tlgMessage) {
set(tlgMessage, message -> {
message.setHide(true);
message.setTelegramMessageId(null);
});
@SuppressWarnings("UnusedReturnValue")
public Optional<MessageDto> setHide(final MaybeInaccessibleMessage tlgMessage, final boolean hide) {
return findByTelegramMessage(tlgMessage).stream().peek(offer -> offer.setHide(hide ? ZonedDateTime.now() : null)).findFirst().map(this::toDto);
}
public void setRemember(@NonNull final TlgMessage tlgMessage, final boolean remember) {
set(tlgMessage, message -> message.setRemember(remember));
public Optional<MessageDto> setRemember(final MaybeInaccessibleMessage tlgMessage, final boolean remember) {
return findByTelegramMessage(tlgMessage).stream().peek(offer -> offer.setRemember(remember)).findFirst().map(this::toDto);
}
@NonNull
public List<MessageDto> findAllDtoByOfferDto(@NonNull final OfferDto offer) {
public Optional<MessageDto> findDtoByTelegramMessage(final MaybeInaccessibleMessage tlgMessage) {
return findByTelegramMessage(tlgMessage).map(this::toDto);
}
public void clearTelegramMessageId(final MessageDto dto) {
findByDto(dto).ifPresent(message -> message.setTelegramMessageId(null));
}
public void setHide(final MessageDto dto, final boolean hide) {
findByDto(dto).ifPresent(offer -> offer.setHide(hide ? ZonedDateTime.now() : null));
}
private Optional<Message> findByTelegramMessage(final MaybeInaccessibleMessage tlgMessage) {
return messageRepository.findByChat_IdAndTelegramMessageId(tlgMessage.getChatId(), tlgMessage.getMessageId());
}
private Optional<Message> findByDto(final MessageDto dto) {
return messageRepository.findById(dto.getId());
}
public List<MessageDto> findAllDtoByOfferDto(final OfferDto offer) {
return messageRepository.findAllByOffer_Id(offer.getId()).stream().map(this::toDto).toList();
}
public void undo(@NonNull final TlgChat chat) {
messageRepository.findFirstByChat_IdAndHideNotNullOrderByHideDesc(chat.id).ifPresentOrElse(
set(message -> message.setHide(false)),
() -> log.warn("Nothing to undo for chat: {}", chat)
);
}
public void markDeleted(@NonNull final TlgMessage tlgMessage) {
set(tlgMessage, message -> {
message.setHide(true);
message.setTelegramMessageId(null);
});
}
private void set(@NonNull final TlgMessage tlgMessage, @NonNull final Consumer<Message> setter) {
find(tlgMessage).ifPresent(set(setter));
}
private Consumer<Message> set(@NonNull final Consumer<Message> setter) {
return message -> {
setter.accept(message);
publish(message);
};
}
private Optional<Message> find(final @NonNull TlgMessage tlgMessage) {
return messageRepository.findByChat_IdAndTelegramMessageId(tlgMessage.chat.id, tlgMessage.id);
}
private void publish(@NonNull final Message message) {
applicationEventPublisher.publishEvent(toDto(message));
}
@NonNull
private MessageDto toDto(@NonNull final Message message) {
private MessageDto toDto(final Message message) {
final ChatDto chatDto = chatService.toDto(message.getChat());
final OfferDto offerDto = offerService.toDto(message.getOffer());
return new MessageDto(message, chatDto, offerDto);
}
@NonNull
public Optional<MessageDto> undo(final long chatId) {
return messageRepository.findFirstByChat_IdAndHideNotNullOrderByHideDesc(chatId).stream().peek(message -> message.setHide(null)).map(this::toDto).findFirst();
}
}

23
src/main/java/de/ph87/kleinanzeigen/telegram/request/ChatRequestEnable.java
View File

@ -1,23 +0,0 @@
package de.ph87.kleinanzeigen.telegram.request;
import de.ph87.kleinanzeigen.telegram.TelegramBot;
import de.ph87.kleinanzeigen.telegram.TlgChat;
import lombok.Getter;
import lombok.NonNull;
import org.telegram.telegrambots.meta.api.objects.Message;
@Getter
public class ChatRequestEnable extends TlgChat {
private final boolean enable;
@NonNull
private final String username;
public ChatRequestEnable(@NonNull final TelegramBot bot, @NonNull final Message message, final boolean enable) {
super(bot, message);
this.enable = enable;
this.username = message.getFrom().getUserName() == null ? "" : message.getFrom().getUserName();
}
}

16
src/main/java/de/ph87/kleinanzeigen/telegram/request/ChatRequestHelp.java
View File

@ -1,16 +0,0 @@
package de.ph87.kleinanzeigen.telegram.request;
import de.ph87.kleinanzeigen.telegram.TelegramBot;
import de.ph87.kleinanzeigen.telegram.TlgChat;
import lombok.Getter;
import lombok.NonNull;
import org.telegram.telegrambots.meta.api.objects.Message;
@Getter
public class ChatRequestHelp extends TlgChat {
public ChatRequestHelp(@NonNull final TelegramBot bot, @NonNull final Message message) {
super(bot, message);
}
}

16
src/main/java/de/ph87/kleinanzeigen/telegram/request/ChatRequestUndo.java
View File

@ -1,16 +0,0 @@
package de.ph87.kleinanzeigen.telegram.request;
import de.ph87.kleinanzeigen.telegram.TelegramBot;
import de.ph87.kleinanzeigen.telegram.TlgChat;
import lombok.Getter;
import lombok.NonNull;
import org.telegram.telegrambots.meta.api.objects.MaybeInaccessibleMessage;
@Getter
public class ChatRequestUndo extends TlgChat {
public ChatRequestUndo(@NonNull final TelegramBot bot, @NonNull final MaybeInaccessibleMessage message) {
super(bot, message);
}
}

16
src/main/java/de/ph87/kleinanzeigen/telegram/request/MessageRequestHide.java
View File

@ -1,16 +0,0 @@
package de.ph87.kleinanzeigen.telegram.request;
import de.ph87.kleinanzeigen.telegram.TelegramBot;
import de.ph87.kleinanzeigen.telegram.TlgMessage;
import lombok.Getter;
import lombok.NonNull;
import org.telegram.telegrambots.meta.api.objects.MaybeInaccessibleMessage;
@Getter
public class MessageRequestHide extends TlgMessage {
public MessageRequestHide(@NonNull final TelegramBot bot, @NonNull final MaybeInaccessibleMessage message) {
super(bot, message);
}
}

19
src/main/java/de/ph87/kleinanzeigen/telegram/request/MessageRequestRemember.java
View File

@ -1,19 +0,0 @@
package de.ph87.kleinanzeigen.telegram.request;
import de.ph87.kleinanzeigen.telegram.TelegramBot;
import de.ph87.kleinanzeigen.telegram.TlgMessage;
import lombok.Getter;
import lombok.NonNull;
import org.telegram.telegrambots.meta.api.objects.MaybeInaccessibleMessage;
@Getter
public class MessageRequestRemember extends TlgMessage {
private final boolean remember;
public MessageRequestRemember(@NonNull final TelegramBot bot, @NonNull final MaybeInaccessibleMessage message, final boolean remember) {
super(bot, message);
this.remember = remember;
}
}