R11/release11-tools-mocked-services
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix for history and allMessages table

Browse Source
This commit is contained in:
Szakalakamaka
2020-09-09 11:04:58 +02:00
parent 87eb042008
commit 34953ed003
44 changed files with 805 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/main/java/com/release11/klaus/controller/KlausController.java
View File

@@ -1,12 +1,14 @@
package com.release11.klaus.controller;
import com.release11.klaus.model.MockedMessageDto;
import com.release11.klaus.utilis.BusinessKey;
import com.release11.klaus.utilis.TrackingClient;
import com.release11.klaus.model.MockedResponseDto;
import com.release11.klaus.model.MockedMessage;
import com.release11.klaus.service.KlausService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
@@ -15,6 +17,7 @@ import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@@ -25,6 +28,15 @@ public class KlausController {
private final KlausService klausService;
@RequestMapping(value = "klaus/v1/getAll/{clientUUID}")
public ResponseEntity<String> getAllMockedResponses(@PathVariable UUID clientUUID){
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
BusinessKey.MESSAGE_ID, "all"));
List<MockedMessageDto> mockedMessages = klausService.getAllMockedResponses(clientUUID);
return new ResponseEntity<>(mockedMessages.toString(), HttpStatus.OK);
}
@RequestMapping(value = "klaus/v1/get/{clientUUID}/{mockedResponseId}")
public ResponseEntity getMockedResponse(@PathVariable UUID clientUUID,
@PathVariable int mockedResponseId){
@@ -44,10 +56,10 @@ public class KlausController {
BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseId)));
MockedResponseDto mockedResponseDto = new MockedResponseDto(clientUUID, mockedResponseId,
MockedMessageDto mockedMessageDto = new MockedMessageDto(clientUUID, mockedResponseId,
requestEntity.getHeaders().getContentType().toString(), requestEntity.getBody(),
requestEntity.getHeaders().toSingleValueMap(), httpStatus);
return klausService.setMockedResponse(mockedResponseDto);
return klausService.setMockedResponse(mockedMessageDto);
}
}

92
src/main/java/com/release11/klaus/controller/KlausMvcController.java
View File

@@ -1,25 +1,25 @@
package com.release11.klaus.controller;
import com.release11.klaus.model.EventRequestDto;
import com.release11.klaus.model.MockedMessageDto;
import com.release11.klaus.service.KlausService;
import com.release11.klaus.utilis.BusinessKey;
import com.release11.klaus.utilis.TrackingClient;
import com.release11.klaus.model.MockedResponseDto;
import com.release11.klaus.service.KlausService;
import lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.*;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.net.InetAddress;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.*;
@Slf4j
@Controller
@@ -28,66 +28,78 @@ import java.util.UUID;
public class KlausMvcController {
private final KlausService klausService;
@GetMapping("/login")
public String login() {
return "login";
}
@GetMapping("/home")
public String showHome(Model model, @RequestParam UUID clientUUID) {
model.addAttribute("mockedResponseDto", new MockedResponseDto(clientUUID, 1,
"application/xml", "body", new HashMap<>(), 200));
@GetMapping({"/home", "/home/{uuid}"})
public String showHome(final MockedMessageDto mockedMessageDto, Model model,
@RequestParam(required = false) UUID clientUUID,
@PathVariable(required = false) UUID uuid) {
if (uuid != null) clientUUID = uuid;
if (clientUUID != null) mockedMessageDto.setClientUUID(clientUUID);
model.addAttribute("mockedMessageDtoList", klausService.getAllMockedResponses(clientUUID));
return "index";
}
//TODO refactor
@PostMapping("/home")
public String showHomePost(@Valid MockedResponseDto mockRsp, BindingResult bindingResult, Model model,
@RequestParam(required = false) String[] header,
@RequestParam(required = false) String[] value) throws Exception {
if (bindingResult.hasErrors()) {
return "index";
}
@PostMapping("/home/{clientUUID}")
public String showHomePost(@Valid final MockedMessageDto mockedMessageDto, BindingResult bindingResult,
final Model model) {
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "setMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(mockRsp.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(mockRsp.getMockedResponseId())));
log.info(mockRsp.toString());
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.valueOf(mockRsp.getMediaType()));
if (header!=null){
for (int i = 0; i < header.length; i++) {
httpHeaders.set(header[i], value[i]);
}}
MockedResponseDto mockedResponseDto = new MockedResponseDto(mockRsp.getClientUUID(), mockRsp.getMockedResponseId(),
mockRsp.getMediaType(), mockRsp.getMessageBody(), httpHeaders.toSingleValueMap(), mockRsp.getHttpStatus());
klausService.setMockedResponse(mockedResponseDto);
BusinessKey.CLIENT_UUID, String.valueOf(mockedMessageDto.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(mockedMessageDto.getMockedResponseId())));
klausService.setMockedResponse(mockedMessageDto);
model.addAttribute("mockedMessageDtoList", klausService.getAllMockedResponses(mockedMessageDto.getClientUUID()));
model.addAttribute("mockSaved", "true");
return "index";
}
@GetMapping("/home/getMockedResponse")
@ResponseBody
public String showGetMockedResponse(MockedResponseDto mockedResponseDto) {
public String showGetMockedResponse(final MockedMessageDto mockedMessageDto) {
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(mockedResponseDto.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseDto.getMockedResponseId())));
return klausService.getMockedResponse(mockedResponseDto.getClientUUID(),
mockedResponseDto.getMockedResponseId()).toString();
BusinessKey.CLIENT_UUID, String.valueOf(mockedMessageDto.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(mockedMessageDto.getMockedResponseId())));
return klausService.getMockedResponse(mockedMessageDto.getClientUUID(),
mockedMessageDto.getMockedResponseId()).toString();
}
private void setHeaders(MockedResponseDto mockedResponseDto, String[] header, String[] value){
@RequestMapping(value = "/home/{clientUUID}", params = {"addHeader"})
public String addRow(final MockedMessageDto mockedMessageDto, @RequestParam String headerKey,
@RequestParam String headerValue) {
mockedMessageDto.getHttpHeaders().put(headerKey, headerValue);
return "index";
}
@RequestMapping(value="/home/{clientUUID}", params={"removeHeader"})
public String removeHeader(final MockedMessageDto mockedMessageDto, final HttpServletRequest req) {
mockedMessageDto.getHttpHeaders().remove(req.getParameter("removeHeader"));
System.out.println(mockedMessageDto);
return "index";
}
@SneakyThrows
@ModelAttribute("localhost")
public String localhost() {
return InetAddress.getLocalHost().getHostName();
}
@ModelAttribute("clientUUID")
public UUID clientUUID(){
public UUID clientUUID() {
return UUID.randomUUID();
}
@ModelAttribute("mockedMessageDto")
public MockedMessageDto mockedMessageDto() {
return new MockedMessageDto(UUID.randomUUID(), 1,
"application/xml", "body", new LinkedHashMap<>(), 200);
}
@ModelAttribute("eventsDto")
public EventRequestDto eventsDto(){
public EventRequestDto eventsDto() {
return EventRequestDto.builder()
.localDateTimeFrom(LocalDateTime.of(LocalDate.now(), LocalTime.MIN))
.localDateTimeTo(LocalDateTime.of(LocalDate.now().plusDays(1), LocalTime.MIDNIGHT))

8
src/main/java/com/release11/klaus/model/Event.java
View File

@@ -1,20 +1,12 @@
package com.release11.klaus.model;
import com.release11.klaus.utilis.BusinessKey;
import lombok.*;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.lang.Nullable;
import javax.persistence.Entity;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@Data
@Entity
@Builder
@ToString
@NoArgsConstructor

1
src/main/java/com/release11/klaus/repository/EventRepositoryImpl.java
View File

@@ -63,7 +63,6 @@ public class EventRepositoryImpl implements EventRepository {
try {
events.add(objectMapper.readValue(eventString, Event.class));
} catch (JsonProcessingException e) {
System.out.println(e);
e.printStackTrace();
}
}

6
src/main/java/com/release11/klaus/repository/MockedResponseRepository.java
View File

@@ -1,13 +1,15 @@
package com.release11.klaus.repository;
import com.release11.klaus.model.MockedResponseDto;
import com.release11.klaus.model.MockedMessage;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.UUID;
@Repository
@Transactional
public interface MockedResponseRepository extends CrudRepository<MockedResponseDto, String>{
public interface MockedResponseRepository extends CrudRepository<MockedMessage, String> {
List<MockedMessage> findAllByClientUUID(UUID clientUUID);
}

9
src/main/java/com/release11/klaus/service/KlausService.java
View File

@@ -1,15 +1,16 @@
package com.release11.klaus.service;
import com.release11.klaus.model.MockedResponseDto;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import com.release11.klaus.model.MockedMessageDto;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.UUID;
@Service
public interface KlausService {
void deleteMockedResponse(UUID clientUUID, int mockedResponseId);
List<MockedMessageDto> getAllMockedResponses(UUID clientUUID);
ResponseEntity<String> getMockedResponse(UUID clientUUID, int mockedResponseId);
ResponseEntity<String> setMockedResponse(MockedResponseDto mockedResponseDto);
ResponseEntity<String> setMockedResponse(MockedMessageDto mockedMessageDto);
}

38
src/main/java/com/release11/klaus/service/KlausServiceImpl.java
View File

@@ -1,6 +1,9 @@
package com.release11.klaus.service;
import com.release11.klaus.model.MockedResponseDto;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.release11.klaus.mappers.MockedMessageMapper;
import com.release11.klaus.model.MockedMessage;
import com.release11.klaus.model.MockedMessageDto;
import com.release11.klaus.repository.MockedResponseRepository;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -9,35 +12,48 @@ import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors;
@Slf4j
@Service
@AllArgsConstructor
public class KlausServiceImpl implements KlausService {
private final ObjectMapper objectMapper;
private final MockedMessageMapper mockedMessageMapper;
private final MockedResponseRepository mockedResponseRepository;
@Override
public void deleteMockedResponse(UUID clientUUID, int mockedResponseId) {
}
@Override
public List<MockedMessageDto> getAllMockedResponses(UUID clientUUID) {
return mockedResponseRepository.findAllByClientUUID(clientUUID).stream()
.map(mockedMessageMapper::mockedMessageToMockedMessageDto)
.collect(Collectors.toList());
}
@Override
public ResponseEntity<String> getMockedResponse(UUID clientUUID, int mockedResponseId) {
log.info("KlausServiceImpl, operation getMockedResponse, clientId {}, mockedResponseId {} ",
clientUUID, mockedResponseId);
String key = clientUUID.toString() + "_" + mockedResponseId;
Optional<MockedResponseDto> optMockedResponseDto = mockedResponseRepository.findById(key);
MockedResponseDto mockedResponseDto = optMockedResponseDto.get();
MockedMessage mockedMessage = mockedResponseRepository.findById(key).get();
HttpHeaders httpHeaders = new HttpHeaders();
mockedResponseDto.getHttpHeaders().forEach(httpHeaders::set);
return new ResponseEntity<>(mockedResponseDto.getMessageBody(), httpHeaders,
Objects.requireNonNull(HttpStatus.valueOf(mockedResponseDto.getHttpStatus())));
if(mockedMessage.getHttpHeaders() !=null)mockedMessage.getHttpHeaders().forEach(httpHeaders::set);
return new ResponseEntity<>(mockedMessage.getMessageBody(), httpHeaders,
Objects.requireNonNull(HttpStatus.valueOf(mockedMessage.getHttpStatus())));
}
@Override
public ResponseEntity<String> setMockedResponse(MockedResponseDto mockedResponseDto) {
mockedResponseRepository.save(mockedResponseDto);
log.info("KlausServiceImpl, operation setMockedResponse, mockedResponseDto {} ", mockedResponseDto.toString());
public ResponseEntity<String> setMockedResponse(MockedMessageDto mockedMessageDto) {
mockedResponseRepository.save(mockedMessageMapper.mockedMessageDtoToMockedMessage(mockedMessageDto));
log.info("KlausServiceImpl, operation setMockedResponse, mockedMessage {} ", mockedMessageDto.toString());
return new ResponseEntity<>("MockedResponse has been setup successfully!", new HttpHeaders(),
HttpStatus.ACCEPTED);
}