killfeed/reports

src/main/java/app/controllers/user/KillFeedController.java

@@ -4,21 +4,29 @@ import app.annotations.enums.AuthMethod;
 import app.annotations.interfaces.CheckWebAccess;
 import app.annotations.interfaces.CollectStatistic;
 import app.annotations.interfaces.WaitAfterNext;
+import app.entities.SearchFilter;
+import app.entities.db.Gametime;
 import app.entities.killfeed.FeedType;
 import app.entities.killfeed.KillsInFeed;
 import app.entities.other.SteamID;
+import app.repositories.GametimeRepository;
+import app.repositories.KillfeedRepository;
+import app.services.ProfileService;
 import app.services.db.KillfeedService;
 import app.utils.SteamIDConverter;
 import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.Pageable;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 
 /**
  * контроллер для получение списка убийств\ассистов\смертей
@@ -28,11 +36,26 @@ import java.util.Map;
 public class KillFeedController {
     private KillfeedService killfeedService;
 
+    @Autowired
+    private ProfileService profileService;
+
+    @Autowired
+    private KillfeedRepository killfeedRepository;
+
+    @Autowired
+    private GametimeRepository gametimeRepository;
+
     @Autowired
     KillFeedController(KillfeedService killfeedService) {
         this.killfeedService = killfeedService;
     }
 
+    private final Function<Long, String> accountId2Nickname = (account_id) -> {
+        if (account_id == null || account_id < 0) return "";
+        Gametime gametime = gametimeRepository.searchGametimeByAccountId(account_id);
+        return gametime == null ? "Unknown" : gametime.getPlayer_name();
+    };
+
     @GetMapping("/weapons")
     @CheckWebAccess(auth_method = AuthMethod.STEAM64)
     @WaitAfterNext(order = "weapons")
@@ -58,6 +81,44 @@ public class KillFeedController {
         return new ResponseEntity(killfeedService.getTopKills(srv), HttpStatus.OK);
     }
 
+    @PostMapping
+    @CheckWebAccess(auth_method = AuthMethod.STEAM64)
+    @WaitAfterNext(order = "killfeed")
+    @CollectStatistic
+    public Page<KillsInFeed> getKillFeed(Pageable pageable,
+                                         @RequestBody(required = false) SearchFilter searchFilter,
+                                         @RequestParam String mode) {
+        if (searchFilter == null) searchFilter = new SearchFilter();
+        List<Long> accs = searchFilter.getAccounts(profileService);
+
+        Page<KillsInFeed> result;
+
+        switch (mode) {
+            case "kills" -> {
+                result = killfeedRepository.getKills(
+                        pageable, accs.isEmpty(), accs, searchFilter.getServerId(), searchFilter.getBeginUnixTime(), searchFilter.getEndUnixTime()
+                );
+            }
+            case "assists" -> {
+                result = killfeedRepository.getAssists(
+                        pageable, accs.isEmpty(), accs, searchFilter.getServerId(), searchFilter.getBeginUnixTime(), searchFilter.getEndUnixTime()
+                );
+            }
+            case "deads" -> {
+                result = killfeedRepository.getDeads(
+                        pageable, accs.isEmpty(), accs, searchFilter.getServerId(), searchFilter.getBeginUnixTime(), searchFilter.getEndUnixTime()
+                );
+            }
+            default -> result = new PageImpl<>(List.of());
+        }
+        result.getContent().forEach(k -> {
+            k.setAssister_name(accountId2Nickname.apply(k.getAssister_id()));
+            k.setVictim_name(accountId2Nickname.apply(k.getVictim_id()));
+            k.setAttacker_name(accountId2Nickname.apply(k.getAttacker_id()));
+        });
+        return result;
+    }
+
     @GetMapping
     @CheckWebAccess(auth_method = AuthMethod.STEAM64)
     @WaitAfterNext(order = "kills")

src/main/java/app/controllers/user/PublicController.java

@@ -7,8 +7,11 @@ import app.annotations.interfaces.WaitAfterNext;
 import app.entities.db.Annonce;
 import app.entities.db.ban.Ban;
 import app.entities.db.ban.BanSearchFilter;
+import app.entities.report.Report;
+import app.entities.report.ReportSearchFilter;
 import app.repositories.AnnonceRepository;
 import app.repositories.BanRepository;
+import app.repositories.ReportRepository;
 import app.services.ProfileService;
 import app.services.db.BanService;
 import jakarta.servlet.http.HttpServletRequest;
@@ -41,6 +44,9 @@ public class PublicController {
     @Autowired
     private ProfileService profileService;
 
+    @Autowired
+    private ReportRepository reportRepository;
+
     @Autowired
     public PublicController(BanService banService) {
         this.banService = banService;
@@ -85,6 +91,25 @@ public class PublicController {
         , HttpStatus.OK);
     }
 
+    @PostMapping("/reports")
+    @CheckWebAccess(auth_method = AuthMethod.STEAM64)
+    @WaitAfterNext(order = "reports")
+    @CollectStatistic
+    public Page<Report> getReports(Pageable pageable,
+                                   @RequestBody(required = false)ReportSearchFilter reportSearchFilter) {
+        if (reportSearchFilter == null) reportSearchFilter = new ReportSearchFilter();
+
+        String al = reportSearchFilter.getAccountsSteam2(profileService);
+        String rl = reportSearchFilter.getAccounts2Steam2(profileService);
+
+        return reportRepository.getReports(pageable,
+                al.isEmpty(), al,
+                rl.isEmpty(), rl,
+                reportSearchFilter.getServerId(),
+                reportSearchFilter.getBeginUnixTime(),
+                reportSearchFilter.getEndUnixTime());
+    }
+
     @GetMapping("/news")
     public ResponseEntity<Page<Annonce>> getNews(Pageable pageable) {
         return ResponseEntity.ok(annonceRepository.getNews(pageable));

src/main/java/app/entities/SearchFilter.java

@@ -1,5 +1,6 @@
 package app.entities;
 
+import app.entities.other.SteamID;
 import app.services.ProfileService;
 import lombok.Setter;
 import org.springframework.format.annotation.DateTimeFormat;
@@ -35,6 +36,20 @@ public class SearchFilter {
                 .toList();
     }
 
+    /**
+     * Выдает список из SteamID Object
+     * @param profileService
+     * @return
+     */
+    public List<SteamID> getAccountsSteamID(ProfileService profileService) {
+        if (accounts == null || accounts.isEmpty()) return new ArrayList<>();
+
+        return accounts.stream()
+                .map(profileService::GetSteamIDFromAnyData)
+                .filter(Objects::nonNull)
+                .toList();
+    }
+
     /**
      * Выдает список из ид 2 версии STEAM_0:0:63666481
      * @param profileService

src/main/java/app/entities/killfeed/KillsInFeed.java

@@ -37,19 +37,19 @@ public class KillsInFeed {
     @Column(name = "attacker_id")
     private Long attacker_id = -1L;
 
-    //
+    @Transient
     private String attacker_name;
 
     @Column(name = "victim_id")
     private Long victim_id = -1L;
 
-    //
+    @Transient
     private String victim_name;
 
     @Column(name = "assister_id")
     private Long assister_id = -1L;
 
-    //
+    @Transient
     private String assister_name;
 
     @Column(name = "utime")

src/main/java/app/entities/report/Report.java

@@ -1,11 +1,15 @@
 package app.entities.report;
 
 import app.entities.other.SteamID;
+import app.entities.server.ServerDB;
 import app.utils.SteamIDConverter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import jakarta.persistence.*;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.List;
+import java.util.stream.Collectors;
 
 @Entity
 @Table(schema = "tf2_facti13", name = "user_reports")
@@ -71,6 +75,16 @@ public class Report {
     @Enumerated(value = EnumType.ORDINAL)
     private ReportType type;
 
+    @JsonIgnore
+    @ManyToOne
+    @JoinColumn(name = "srv", referencedColumnName = "srv_id", insertable = false, updatable = false)
+    private ServerDB serverDB;
+
+    @OneToMany
+    @JsonIgnore
+    @JoinColumn(name = "report_id", referencedColumnName = "id", insertable = false, updatable = false)
+    private List<ReportAction> reportActions;
+
     public Report(ResultSet rs) throws SQLException {
         id = rs.getLong("id");
         //
@@ -174,4 +188,12 @@ public class Report {
     public boolean selfReport() {
         return r_nickname == null && r_steam2 == null;
     }
+
+    public String getServerName() {
+        return serverDB == null ? "Unknown" : serverDB.getName();
+    }
+
+    public List<String> getActions() {
+        return reportActions == null ? List.of() : reportActions.stream().map(ReportAction::getAction).collect(Collectors.toList());
+    }
 }

src/main/java/app/entities/report/ReportAction.java

@@ -0,0 +1,22 @@
+package app.entities.report;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.Data;
+
+@Entity
+@Table(schema = "tf2_facti13", name = "user_reports_action")
+@Data
+public class ReportAction {
+    @Id
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "report_id")
+    private Long reportId;
+
+    @Column(name = "action")
+    private String action;
+}

src/main/java/app/entities/report/ReportSearchFilter.java

@@ -0,0 +1,29 @@
+package app.entities.report;
+
+import app.entities.SearchFilter;
+import app.services.ProfileService;
+
+import java.util.List;
+import java.util.Objects;
+
+public class ReportSearchFilter extends SearchFilter {
+    private List<String> accounts_2 = null;
+
+    public ReportSearchFilter() {
+    }
+
+    /**
+     * Выдает список из ид 2 версии STEAM_0:0:63666481
+     * @param profileService
+     * @return
+     */
+    public String getAccounts2Steam2(ProfileService profileService) {
+        if (accounts_2 == null || accounts_2.isEmpty()) return "";
+
+        return String.join(",", accounts_2.stream()
+                .map(profileService::GetSteamIDFromAnyData)
+                .filter(Objects::nonNull)
+                .map(sId -> sId.steam2)
+                .toList());
+    }
+}

src/main/java/app/entities/server/ServerDB.java

@@ -1,5 +1,6 @@
 package app.entities.server;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.Id;
@@ -16,6 +17,7 @@ public class ServerDB {
     private String name;
 
     @Column(name = "description")
+    @JsonIgnore
     private String description;
 
     public ServerDB() {

src/main/java/app/repositories/KillfeedRepository.java

@@ -22,13 +22,16 @@ public interface KillfeedRepository extends PagingAndSortingRepository<KillsInFe
             @Param("utime") Long utime);
 
     @Query(value = "select k from KillsInFeed k where " +
-            "(:utime is null or k.utime >= :utime) and " +
+            "(:begin_date is null or k.utime >= :begin_date) and " +
+            "(:end_date is null or :end_date >= k.utime) and " +
             "(:server_id is null or k.server_id like :server_id) and" +
-            "(:account_id is null or (k.attacker_id in :accounts_id and k.attacker_id != k.victim_id)) order by k.id desc")
+            "(:accounts_id_non_exists = true or (k.attacker_id in :accounts_id and k.attacker_id != k.victim_id)) order by k.id desc")
     Page<KillsInFeed> getKills(Pageable pageable,
+                               @Param("accounts_id_non_exists") boolean accounts_id_non_exists,
                                @Param("accounts_id") Iterable<Long> accounts_id,
                                @Param("server_id") String server_id,
-                               @Param("utime") Long utime);
+                               @Param(value = "begin_date") Long begin_date,
+                               @Param(value = "end_date") Long end_date);
 
     //deads
     @Query(value = "select count(k) from KillsInFeed k where " +
@@ -41,13 +44,16 @@ public interface KillfeedRepository extends PagingAndSortingRepository<KillsInFe
             @Param("utime") Long utime);
 
     @Query(value = "select k from KillsInFeed k where " +
-            "(:utime is null or k.utime >= :utime) and " +
+            "(:begin_date is null or k.utime >= :begin_date) and " +
+            "(:end_date is null or :end_date >= k.utime) and " +
             "(:server_id is null or k.server_id like :server_id) and" +
-            "(:account_id is null or (k.victim_id in :accounts_id and k.attacker_id != k.victim_id)) order by k.id desc")
+            "(:accounts_id_non_exists = true or (k.victim_id in :accounts_id and k.attacker_id != k.victim_id)) order by k.id desc")
     Page<KillsInFeed> getDeads(Pageable pageable,
+                               @Param("accounts_id_non_exists") boolean accounts_id_non_exists,
                                @Param("accounts_id") Iterable<Long> accounts_id,
                                @Param("server_id") String server_id,
-                               @Param("utime") Long utime);
+                               @Param(value = "begin_date") Long begin_date,
+                               @Param(value = "end_date") Long end_date);
 
     //suisides
     @Query(value = "select count(k) from KillsInFeed k where " +
@@ -71,11 +77,14 @@ public interface KillfeedRepository extends PagingAndSortingRepository<KillsInFe
             @Param("utime") Long utime);
 
     @Query(value = "select k from KillsInFeed k where " +
-            "(:utime is null or k.utime >= :utime) and " +
+            "(:begin_date is null or k.utime >= :begin_date) and " +
+            "(:end_date is null or :end_date >= k.utime) and " +
             "(:server_id is null or k.server_id like :server_id) and" +
-            "(:account_id is null or k.assister_id in :accounts_id) order by k.id desc")
+            "(:accounts_id_non_exists = true or k.assister_id in :accounts_id) order by k.id desc")
     Page<KillsInFeed> getAssists(Pageable pageable,
-                               @Param("accounts_id") Iterable<Long> accounts_id,
-                               @Param("server_id") String server_id,
-                               @Param("utime") Long utime);
+                                @Param("accounts_id_non_exists") boolean accounts_id_non_exists,
+                                @Param("accounts_id") Iterable<Long> accounts_id,
+                                @Param("server_id") String server_id,
+                                @Param(value = "begin_date") Long begin_date,
+                                @Param(value = "end_date") Long end_date);
 }

src/main/java/app/repositories/ReportRepository.java

@@ -0,0 +1,27 @@
+package app.repositories;
+
+import app.entities.report.Report;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.data.repository.query.Param;
+
+public interface ReportRepository extends PagingAndSortingRepository<Report, Long> {
+    @Query(value = "select r from Report r where " +
+            "(:authors_ne = true or position(r.a_steam2 in :authors) > 0) and " +
+            "(:reportes_ne = true or position(r.r_steam2 in :reportes) > 0) and " +
+            "(:begin_date is null or r.utime >= :begin_date) and " +
+            "(:end_date is null or :end_date >= r.utime) and " +
+            "(:server_id is null or r.srv like :server_id) order by r.id desc"
+    )
+    Page<Report> getReports(Pageable pageable,
+                            @Param("authors_ne") boolean authors_ne,//a
+                            @Param("authors") String authors,
+                            @Param("reportes_ne") boolean reportes_ne,//r
+                            @Param("reportes") String reportes,
+                            //
+                            @Param("server_id") String server_id,
+                            @Param(value = "begin_date") Long begin_date,
+                            @Param(value = "end_date") Long end_date);
+}

src/main/java/app/services/db/KillfeedService.java

@@ -117,13 +117,16 @@ public class KillfeedService {
         return killfeedRepository.getAssists(steamID.account_id, server_id, utime);
     }
 
+    @Deprecated
     public Page<KillsInFeed> getKills(Pageable pageable, List<SteamID> accounts, String server_id, boolean current) {
+        List<Long> accs = accounts.stream()
+                .filter(Objects::nonNull)
+                .map(s -> s.account_id).toList();
         Page<KillsInFeed> result = killfeedRepository.getKills(
                 pageable,
-                accounts.stream()
-                        .filter(Objects::nonNull)
-                        .map(s -> s.account_id).toList(),
-                server_id, current ? Instant.now().getEpochSecond() : null);
+                accs.isEmpty(),
+                accs,
+                server_id, current ? Instant.now().getEpochSecond() : null, null);
         result.getContent().forEach(k -> {
             k.setAssister_name(accountId2Nickname.apply(k.getAssister_id()));
             k.setVictim_name(accountId2Nickname.apply(k.getVictim_id()));
@@ -132,13 +135,16 @@ public class KillfeedService {
         return result;
     }
 
+    @Deprecated
     public Page<KillsInFeed> getDeads(Pageable pageable, List<SteamID> accounts, String server_id, boolean current) {
+        List<Long> accs = accounts.stream()
+                .filter(Objects::nonNull)
+                .map(s -> s.account_id).toList();
         Page<KillsInFeed> result = killfeedRepository.getDeads(
                 pageable,
-                accounts.stream()
-                        .filter(Objects::nonNull)
-                        .map(s -> s.account_id).toList(),
-                server_id, current ? Instant.now().getEpochSecond() : null);
+                accs.isEmpty(),
+                accs,
+                server_id, current ? Instant.now().getEpochSecond() : null, null);
         result.getContent().forEach(k -> {
             k.setAssister_name(accountId2Nickname.apply(k.getAssister_id()));
             k.setVictim_name(accountId2Nickname.apply(k.getVictim_id()));
@@ -147,13 +153,16 @@ public class KillfeedService {
         return result;
     }
 
+    @Deprecated
     public Page<KillsInFeed> getAssists(Pageable pageable, List<SteamID> accounts, String server_id, boolean current) {
+        List<Long> accs = accounts.stream()
+                .filter(Objects::nonNull)
+                .map(s -> s.account_id).toList();
         Page<KillsInFeed> result = killfeedRepository.getAssists(
                 pageable,
-                accounts.stream()
-                        .filter(Objects::nonNull)
-                        .map(s -> s.account_id).toList(),
-                server_id, current ? Instant.now().getEpochSecond() : null);
+                accs.isEmpty(),
+                accs,
+                server_id, current ? Instant.now().getEpochSecond() : null, null);
         result.getContent().forEach(k -> {
             k.setAssister_name(accountId2Nickname.apply(k.getAssister_id()));
             k.setVictim_name(accountId2Nickname.apply(k.getVictim_id()));