Facti13.Web.Backend.Java.V2/src/main/java/app/controllers/user/PublicController.java

package app.controllers.user;

import app.annotations.enums.AuthMethod;
import app.annotations.enums.FirstTouch;
import app.annotations.interfaces.CheckPermitionFlag;
import app.annotations.interfaces.CheckWebAccess;
import app.annotations.interfaces.CollectStatistic;
import app.annotations.interfaces.WaitAfterNext;
import app.entities.SearchFilter;
import app.entities.db.Annonce;
import app.entities.db.ban.Ban;
import app.entities.db.ban.BanSearchFilter;
import app.entities.db.period.PerPeriodStatistic;
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 app.services.db.GraphService;
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.sql.Timestamp;
import java.time.Instant;
import java.util.HashMap;
import java.util.List;

/**
 * контролллер для просмотра всякой хуйни, например банлиста (нахуя он отдельный, незнаю, захотел)
 */
@RestController
@RequestMapping("api/web")
public class PublicController {

    BanService banService;

    @Autowired
    private AnnonceRepository annonceRepository;

    @Autowired
    private BanRepository banRepository;

    @Autowired
    private ProfileService profileService;

    @Autowired
    private ReportRepository reportRepository;

    @Autowired
    private GraphService graphService;

    @Autowired
    public PublicController(BanService banService) {
        this.banService = banService;
    }

    @GetMapping("/banlist")
    @CheckWebAccess(auth_method = AuthMethod.STEAM64)
    @WaitAfterNext(order = "banlist")
    @CollectStatistic
    @Deprecated
    public ResponseEntity<HashMap> getBanList(
            HttpServletRequest request,
            @RequestParam(required = false, defaultValue = "20") Integer limit,
            @RequestParam(required = false, defaultValue = "0") Long offset) {
        if (limit > 20) return new ResponseEntity<>(HttpStatus.NOT_ACCEPTABLE);

        return new ResponseEntity<>(new HashMap<>(){{
            put("bans", banService.getLastBans(limit,offset));
            put("count", banService.getBansCount());
        }}, HttpStatus.OK);
    }

    @PostMapping("/banlist")
    @CheckWebAccess(auth_method = AuthMethod.STEAM64, firstTouch = FirstTouch.FIRST_PAGE)
    @WaitAfterNext(order = "banlist")
    @CollectStatistic
    public ResponseEntity<Page<Ban>> getBanListWithFilters(Pageable pageable, @RequestBody(required = false) BanSearchFilter banSearchFilter) {
        if (banSearchFilter == null) banSearchFilter = new BanSearchFilter();

        List<Long> ban_ids = banSearchFilter.getBan_ids();
        List<Long> account_ids = banSearchFilter.getAccounts(profileService);
        List<String> admin_ids = banSearchFilter.getAdminIds(profileService);

        return new ResponseEntity<>(
                banRepository.getBans(pageable,
                        ban_ids.isEmpty(), ban_ids,
                        account_ids.isEmpty(), account_ids,
                        banSearchFilter.getBeginUnixTime() == null ? 0L : banSearchFilter.getBeginUnixTime(),
                        banSearchFilter.getEndUnixTime() == null ? 0L : banSearchFilter.getEndUnixTime(),
                        banSearchFilter.getActive(),
                        admin_ids.isEmpty(), admin_ids, banSearchFilter.getReason(),
                        banSearchFilter.getBeginUnixTime(),
                        banSearchFilter.getEndUnixTime())
        , HttpStatus.OK);
    }

    @PostMapping("/reports")
    @CheckWebAccess(auth_method = AuthMethod.STEAM64, firstTouch = FirstTouch.FIRST_PAGE)
    @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));
    }

    @GetMapping("/annonces")
    public ResponseEntity<Page<Annonce>> getAnnonces(Pageable pageable) {
        return ResponseEntity.ok(annonceRepository.getAnnonce(pageable));
    }

    @PostMapping("/vip/graph")
    @WaitAfterNext(order = "vipgraph")
    public ResponseEntity<List<GraphService.VipPerPeriodStatistic>> getTimeOnPeriod(@RequestBody(required = false) SearchFilter searchFilter) {
        if (searchFilter == null) searchFilter = new SearchFilter();
        if (searchFilter.getEndTime() == null)
            searchFilter.setEnd(Timestamp.from(Instant.now()).toLocalDateTime());
        if (searchFilter.getBeginTime() == null)
            searchFilter.setBegin(Timestamp.from(Instant.now().minusSeconds(30 * 3600* 24)).toLocalDateTime());
        searchFilter.setEndOrBeginTimeOfDay();

        return new ResponseEntity<>(graphService.getVipOnPeriod(
                searchFilter
        ), HttpStatus.OK);
    }

    @PostMapping("/doxing/graph")
    @WaitAfterNext(order = "doxing")
    @CheckWebAccess
    @CheckPermitionFlag(flag = "d")
    public ResponseEntity<List<GraphService.CountryCityPerPeriodStatistic>> getDoxing(@RequestBody(required = false) SearchFilter searchFilter) {
        if (searchFilter == null) return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        if (searchFilter.getEndTime() == null)
            searchFilter.setEnd(Timestamp.from(Instant.now()).toLocalDateTime());
        if (searchFilter.getBeginTime() == null)
            searchFilter.setBegin(Timestamp.from(Instant.now().minusSeconds(30 * 3600* 24)).toLocalDateTime());
        searchFilter.setEndOrBeginTimeOfDay();

        return new ResponseEntity<>(graphService.getDoxingOnPeriod(
                searchFilter
        ), HttpStatus.OK);
    }
}