Initial commit: bositao cloud (jnpf-java-cloud-v6x)

刘光辉

117 分钟以前 06f314545ac3514d7ce28939920866ae8188d31c

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package jnpf.elnController;
 
import jnpf.elnService.ElnRecordFillTicketService;
import jnpf.elnService.ElnRecordFillDataService;
import jnpf.elnService.ElnRecordRepeatService;
import jnpf.elnService.ElnRecordSourceSyncService;
import jnpf.elnEntity.runtime.ElnRecordForms;
import jnpf.elnEntity.runtime.ElnRecordVos;
import jnpf.util.NoDataSourceBind;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
 
@RestController
@RequestMapping({"/onlyoffice/recordFill", "/onlyoffice/templateFill"})
public class ElnRecordFillController {
 
    private static final String TICKET_PREFIX = "Ticket ";
    private final ElnRecordFillTicketService ticketService;
    private final ElnRecordFillDataService recordFillDataService;
    private final ElnRecordRepeatService recordRepeatService;
    private final ElnRecordSourceSyncService recordSourceSyncService;
 
    ElnRecordFillController(ElnRecordFillTicketService ticketService) {
        this(ticketService, ticket -> Collections.emptyMap(), null, null);
    }
 
    public ElnRecordFillController(ElnRecordFillTicketService ticketService,
                                  ElnRecordFillDataService recordFillDataService) {
        this(ticketService, recordFillDataService, null, null);
    }
 
    public ElnRecordFillController(ElnRecordFillTicketService ticketService,
                                  ElnRecordFillDataService recordFillDataService,
                                  ElnRecordRepeatService recordRepeatService) {
        this(ticketService, recordFillDataService, recordRepeatService, null);
    }
 
    @Autowired
    public ElnRecordFillController(ElnRecordFillTicketService ticketService,
                                  ElnRecordFillDataService recordFillDataService,
                                  ElnRecordRepeatService recordRepeatService,
                                  ElnRecordSourceSyncService recordSourceSyncService) {
        this.ticketService = ticketService;
        this.recordFillDataService = recordFillDataService;
        this.recordRepeatService = recordRepeatService;
        this.recordSourceSyncService = recordSourceSyncService;
    }
 
    @PostMapping("/sourceSync/preview")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.SourceSyncPreview> previewSourceSync(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization) {
        try {
            return ResponseEntity.ok(recordSourceSyncService.preview(parseTicket(authorization)));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }
 
    @PostMapping("/sourceSync")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.SourceSynchronized> synchronizeSource(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
            @RequestBody(required = false) ElnRecordForms.SourceSync command) {
        try {
            return ResponseEntity.ok(
                    recordSourceSyncService.synchronize(parseTicket(authorization), command));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }
 
    @GetMapping("/data")
    @NoDataSourceBind
    public ResponseEntity<Map<String, Object>> data(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization) {
        try {
            ElnRecordFillTicketService.FillTicketContext ticket = parseTicket(authorization);
            ElnRecordVos.SourceSynchronized pending = recordSourceSyncService == null
                    ? null : recordSourceSyncService.pending(ticket);
            Map<String, Object> data = new LinkedHashMap<>(recordFillDataService.data(ticket));
            if (recordSourceSyncService != null) {
                data.put("pendingSourceSync", pending);
            }
            return ResponseEntity.ok(data);
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(Collections.emptyMap());
        }
    }
 
    @PostMapping("/repeatRows")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.RepeatRow> appendRepeatRow(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
            @RequestBody(required = false) ElnRecordForms.RepeatAppend form) {
        try {
            ElnRecordFillTicketService.FillTicketContext ticket = parseTicket(authorization);
            return ResponseEntity.ok(recordRepeatService.append(ticket, form));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }
 
    @PostMapping("/repeatRows/delete")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.RepeatRow> deleteRepeatRow(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
            @RequestBody(required = false) ElnRecordForms.RepeatDelete form) {
        try {
            ElnRecordFillTicketService.FillTicketContext ticket = parseTicket(authorization);
            return ResponseEntity.ok(recordRepeatService.requestDelete(ticket, form));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }
 
    @PostMapping("/repeatRows/restore")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.RepeatRow> restoreRepeatRow(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
            @RequestBody(required = false) ElnRecordForms.RepeatRestore form) {
        try {
            ElnRecordFillTicketService.FillTicketContext ticket = parseTicket(authorization);
            return ResponseEntity.ok(recordRepeatService.restoreDelete(ticket, form));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }
 
    private ElnRecordFillTicketService.FillTicketContext parseTicket(String authorization) {
        if (authorization == null || !authorization.startsWith(TICKET_PREFIX)
                || authorization.length() == TICKET_PREFIX.length()) {
            throw new ElnRecordFillTicketService.InvalidFillTicketException();
        }
        return ticketService.parse(authorization.substring(TICKET_PREFIX.length()).trim());
    }
}