anapi-v2/src/main/java/dev/vality/anapi/v2/api/ReportsApiDelegateService.java at a5338b63cb8cbd2580455de0fa0631a6c64fd599 · valitydev/anapi-v2 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package dev.vality.anapi.v2.api;

import dev.vality.anapi.v2.converter.reporter.request.ParamsToStatReportRequestConverter;
import dev.vality.anapi.v2.model.InlineResponse20013;
import dev.vality.anapi.v2.model.Report;
import dev.vality.anapi.v2.model.ReportLink;
import dev.vality.anapi.v2.security.AccessData;
import dev.vality.anapi.v2.security.AccessService;
import dev.vality.anapi.v2.service.ReporterService;
import dev.vality.anapi.v2.util.DeadlineUtil;
import dev.vality.geck.common.util.TypeUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.temporal.ChronoUnit;
import java.util.List;

@Service
@RequiredArgsConstructor
@Slf4j
@SuppressWarnings({"ParameterName"})
public class ReportsApiDelegateService implements ReportsApiDelegate {

    public static final String RES_LOG_200 = "<- Res [200]: xRequestID={}";
    private final AccessService accessService;
    private final ReporterService reporterService;

    private final ParamsToStatReportRequestConverter statReportRequestConverter;
    @Value("${service.reporter.reportUrlLifetimeSec}")
    private long reportLifetimeSec = 60L;

    @Override
    public ResponseEntity<Void> cancelReport(String xRequestID,
                                             String partyID,
                                             Long reportID,
                                             String xRequestDeadline) {
        DeadlineUtil.checkDeadline(xRequestDeadline, xRequestID);
        accessService.checkUserAccess(
                AccessData.builder()
                        .operationId("CancelReport")
                        .partyId(partyID)
                        .reportId(String.valueOf(reportID))
                        .build());
        reporterService.cancelReport(reportID);
        log.info("<- Res [202]: xRequestID={}", xRequestID);
        return ResponseEntity.accepted().build();
    }

    @Override
    public ResponseEntity<Report> createReport(String xRequestID, String partyID, OffsetDateTime fromTime,
                                               OffsetDateTime toTime, String reportType, String xRequestDeadline,
                                               String shopID) {
        DeadlineUtil.checkDeadline(xRequestDeadline, xRequestID);
        var shops = shopID != null ? List.of(shopID) : null;
        accessService.checkUserAccess(
                AccessData.builder()
                        .operationId("CreateReport")
                        .partyId(partyID)
                        .shopIds(shops)
                        .build());
        var request = statReportRequestConverter.mapToReportRequest(partyID, shopID, fromTime, toTime);
        var reportId = reporterService.createReport(request, statReportRequestConverter.mapReportType(reportType));
        var response = reporterService.getReport(reportId);
        log.info("<- Res [201]: xRequestID={}", xRequestID);
        return ResponseEntity.status(HttpStatus.CREATED).body(response);
    }

    @Override
    public ResponseEntity<ReportLink> downloadFile(String xRequestID, String partyID, Long reportID, String fileID,
                                                   String xRequestDeadline) {
        DeadlineUtil.checkDeadline(xRequestDeadline, xRequestID);
        accessService.checkUserAccess(
                AccessData.builder()
                        .operationId("DownloadFile")
                        .partyId(partyID)
                        .fileId(fileID)
                        .reportId(String.valueOf(reportID))
                        .build());
        var response = reporterService.getDownloadUrl(fileID,
                TypeUtil.temporalToString(LocalDateTime.now().plus(reportLifetimeSec, ChronoUnit.SECONDS)));
        log.info(RES_LOG_200, xRequestID);
        return ResponseEntity.ok(response);
    }

    @Override
    public ResponseEntity<Report> getReport(String xRequestID, String partyID, Long reportID, String xRequestDeadline) {
        DeadlineUtil.checkDeadline(xRequestDeadline, xRequestID);
        accessService.checkUserAccess(
                AccessData.builder()
                        .operationId("GetReport")
                        .partyId(partyID)
                        .reportId(String.valueOf(reportID))
                        .build());
        var response = reporterService.getReport(reportID);
        log.info(RES_LOG_200, xRequestID);
        return ResponseEntity.ok(response);
    }

    @Override
    public ResponseEntity<InlineResponse20013> searchReports(String xRequestID, String partyID, OffsetDateTime fromTime,
                                                             OffsetDateTime toTime, Integer limit,
                                                             List<String> reportTypes, String xRequestDeadline,
                                                             String shopID, String paymentInstitutionRealm,
                                                             String continuationToken) {
        DeadlineUtil.checkDeadline(xRequestDeadline, xRequestID);
        List<String> shopIDs = accessService.getRestrictedShops(
                AccessData.builder()
                        .operationId("SearchReports")
                        .partyId(partyID)
                        .shopIds(shopID == null ? null : List.of(shopID))
                        .realm(paymentInstitutionRealm)
                        .build());
        InlineResponse20013 response;
        if (shopID == null || shopIDs.contains(shopID)) {
            var request =
                    statReportRequestConverter.convert(partyID, shopID, fromTime, toTime, limit, reportTypes,
                            continuationToken);
            response = reporterService.getReports(request);
        } else {
            response = new InlineResponse20013();
        }
        log.info(RES_LOG_200, xRequestID);
        return ResponseEntity.ok(response);
    }

}