1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.logging.log4j.catalog.controller;
18
19 import javax.annotation.PostConstruct;
20 import java.lang.reflect.Type;
21 import java.util.ArrayList;
22 import java.util.HashMap;
23 import java.util.List;
24 import java.util.Map;
25 import java.util.Optional;
26
27 import org.apache.logging.log4j.LogManager;
28 import org.apache.logging.log4j.Logger;
29 import org.apache.logging.log4j.catalog.api.Event;
30 import org.apache.logging.log4j.catalog.jpa.model.EventModel;
31 import org.apache.logging.log4j.catalog.jpa.service.EventService;
32 import org.apache.logging.log4j.catalog.jpa.converter.EventConverter;
33 import org.apache.logging.log4j.catalog.jpa.converter.EventModelConverter;
34 import org.modelmapper.ModelMapper;
35 import org.modelmapper.TypeToken;
36 import org.springframework.beans.factory.annotation.Autowired;
37 import org.springframework.http.HttpStatus;
38 import org.springframework.http.ResponseEntity;
39 import org.springframework.web.bind.annotation.PostMapping;
40 import org.springframework.web.bind.annotation.RequestBody;
41 import org.springframework.web.bind.annotation.RequestMapping;
42 import org.springframework.web.bind.annotation.RequestParam;
43 import org.springframework.web.bind.annotation.RestController;
44
45
46
47
48
49 @RequestMapping(value = "/api/events")
50 @RestController
51 public class EventController {
52 private static final Logger LOGGER = LogManager.getLogger();
53
54 private ModelMapper modelMapper = new ModelMapper();
55
56 @Autowired
57 private EventService eventService;
58
59 @Autowired
60 private EventModelConverter eventModelConverter;
61
62 @Autowired
63 private EventConverter eventConverter;
64
65 @PostConstruct
66 public void init() {
67 modelMapper.addConverter(eventModelConverter);
68 }
69
70 @PostMapping(value = "/list")
71 public ResponseEntity<Map<String, Object>> eventList(@RequestParam(value="jtStartIndex", required=false) Integer startIndex,
72 @RequestParam(value="jtPageSize", required=false) Integer pageSize,
73 @RequestParam(value="jtSorting", required=false) String sorting) {
74 Type listType = new TypeToken<List<Event>>() {}.getType();
75 Map<String, Object> response = new HashMap<>();
76 try {
77 List<Event> events = null;
78 if (startIndex == null || pageSize == null) {
79 events = modelMapper.map(eventService.getEvents(), listType);
80 } else {
81 int startPage = 0;
82 if (startIndex > 0) {
83 startPage = startIndex / pageSize;
84 }
85 String sortColumn = "name";
86 String sortDirection = "ASC";
87 if (sorting != null) {
88 String[] sortInfo = sorting.split(" ");
89 sortColumn = sortInfo[0];
90 if (sortInfo.length > 0) {
91 sortDirection = sortInfo[1];
92 }
93 }
94 events = modelMapper.map(eventService.getEvents(startPage, pageSize, sortColumn, sortDirection), listType);
95 }
96 if (events == null) {
97 events = new ArrayList<>();
98 }
99 response.put("Result", "OK");
100 response.put("Records", events);
101 } catch (Exception ex) {
102 response.put("Result", "FAILURE");
103 response.put("Message", ex.getMessage());
104 }
105 return new ResponseEntity<>(response, HttpStatus.OK);
106 }
107
108 @PostMapping(value = "/create")
109 public ResponseEntity<Map<String, Object>> createEvent(@RequestBody Event event) {
110 Map<String, Object> response = new HashMap<>();
111 try {
112 EventModel model = eventConverter.convert(event);
113 event = eventModelConverter.convert(eventService.saveEvent(model));
114 response.put("Result", "OK");
115 response.put("Records", event);
116 } catch (Exception ex) {
117 response.put("Result", "FAILURE");
118 response.put("Message", ex.getMessage());
119 LOGGER.warn("Unable to create event named {}", event.getName(), ex);
120 }
121 return new ResponseEntity<>(response, HttpStatus.OK);
122 }
123
124 @PostMapping(value = "/update")
125 public ResponseEntity<Map<String, Object>> updateEvent(@RequestBody Event event) {
126 Map<String, Object> response = new HashMap<>();
127 try {
128 EventModel model = eventConverter.convert(event);
129 event = eventModelConverter.convert(eventService.saveEvent(model));
130 response.put("Result", "OK");
131 response.put("Records", event);
132 } catch (Exception ex) {
133 response.put("Result", "FAILURE");
134 response.put("Message", ex.getMessage());
135 LOGGER.warn("Unable to update event named {}", event.getName(), ex);
136 }
137 return new ResponseEntity<>(response, HttpStatus.OK);
138 }
139
140 @PostMapping(value = "/delete")
141 public ResponseEntity<Map<String, Object>> deleteEvent(@RequestBody Long eventId) {
142 Map<String, Object> response = new HashMap<>();
143 try {
144 eventService.deleteEvent(eventId);
145 response.put("Result", "OK");
146 } catch (Exception ex) {
147 response.put("Result", "FAILURE");
148 response.put("Message", ex.getMessage());
149 }
150 return new ResponseEntity<>(response, HttpStatus.OK);
151 }
152
153 @PostMapping(value = "/attributes/list")
154 public ResponseEntity<Map<String, Object>> attributeList(@RequestParam("eventId") Long eventId) {
155 Map<String, Object> response = new HashMap<>();
156 try {
157 Optional<EventModel> optional = eventService.getEvent(eventId);
158 if (optional.isPresent()) {
159 Event event = eventModelConverter.convert(optional.get());
160 response.put("Result", "OK");
161 if (event != null && event.getAttributes() != null) {
162 response.put("Records", event.getAttributes());
163 } else {
164 response.put("Records", new ArrayList<>());
165 }
166 } else {
167 response.put("Result", "OK");
168 response.put("Records", new ArrayList<>());
169
170 }
171 } catch (Exception ex) {
172 response.put("Result", "FAILURE");
173 }
174 return new ResponseEntity<>(response, HttpStatus.OK);
175 }
176 }