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

New todo, removal of old commented code

Browse Source
This commit is contained in:
Gabriel Modzelewski
2021-02-09 16:48:09 +01:00
parent cad85ec8af
commit a71c36e40a
6 changed files with 23 additions and 305 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2,7 +2,6 @@ package com.release11.klaus.controller;
import com.release11.klaus.model.MockedMessageDto;
import com.release11.klaus.model.MockedMessageDtoTest;
import com.release11.klaus.service.KlausService;
import com.release11.klaus.utilis.BusinessKey;
import com.release11.klaus.utilis.TrackingClient;
@@ -13,10 +12,15 @@ import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import java.time.LocalDateTime;
import java.util.*;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
/**
@@ -30,40 +34,6 @@ import java.util.*;
public class KlausController {
private final KlausService klausService;
MockedMessageDto msg = MockedMessageDto.builder()
.clientUUID(UUID.randomUUID())
.httpStatus(200)
.mediaType("text/xml")
.messageBody("Hello world")
.mockedResponseId(1)
.httpHeaders(new HashMap<>())
.build();
@ResponseBody
@GetMapping(value = "klaus/v1/get/test/msgtest")
public MockedMessageDtoTest getTestMessageTest(){
MockedMessageDtoTest msg = new MockedMessageDtoTest();
return msg;
}
@ResponseBody
@GetMapping(value = "klaus/v1/get/test/msg")
public MockedMessageDto getTestMessage(){
Map<String, String> headers = new HashMap<>();
headers.put("Keep-Alive", "timeout=60");
headers.put("Connection", "keep-alive");
headers.put("Date", LocalDateTime.now().toString());
MockedMessageDto msg = MockedMessageDto.builder()
.clientUUID(UUID.randomUUID())
.httpStatus(200)
.mediaType("text/xml")
.messageBody("Hello world")
.mockedResponseId(1)
.httpHeaders(headers)
.build();
return msg;
}
@DeleteMapping(value = "klaus/v1/delete/{clientUUID}/{mockedResponseId}")

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

@@ -1,256 +0,0 @@
package com.release11.klaus.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
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 lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
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.LocalDateTime;
import java.util.*;
/**
* Sending GET request to path /mock sets up a new UUID ex. 58b9709d-358b-4713-8fbc-6acf89e81418
* UUID is something like session id type which contains references to each saved message
* Next saved massage shares UUID but its id is a +1 ex.
* 58b9709d-358b-4713-8fbc-6acf89e81418/1; 58b9709d-358b-4713-8fbc-6acf89e81418/2 etc.
*/
@Slf4j
@Controller
@RequestMapping("/old")
@AllArgsConstructor
public class KlausMvcController {
private final KlausService klausService;
@Autowired
private static MockedMessageDto globalMockedMessageDto;
private final Set<MockedMessageDto> globalMockedMessageDtoList = new HashSet<>();
@SneakyThrows
@GetMapping({"/mock", "/mock/{uuid}"})
public String showHome(final MockedMessageDto mockedMessageDto, final Model model,
@RequestParam(required = false) UUID clientUUID,
@PathVariable(required = false) UUID uuid) {
if (uuid != null) clientUUID = uuid;
if (clientUUID != null) mockedMessageDto.setClientUUID(clientUUID);
else mockedMessageDto.setClientUUID(UUID.randomUUID());
populateModelVars(model, mockedMessageDto,true);
return "mock";
}
// @GetMapping("/mock/raw/{uuid}")
// public MockedMessageDto getJsonMessageDto(){
// return globalMockedMessageDto;
// }
@PostMapping("/mock/{uuid}")
public String showHomePost(@Valid MockedMessageDto mockedMessageDto, BindingResult bindingResult, Model model) {
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "setMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(mockedMessageDto.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(mockedMessageDto.getMockedResponseId())));
if (bindingResult.hasErrors()){
populateModelVars(model, mockedMessageDto,false);
return "index";
}
klausService.setMockedResponse(mockedMessageDto);
populateModelVars(model, mockedMessageDto,true);
model.addAttribute("mockSaved", "true");
model.addAttribute("canTest", "true");
return "mock";
}
@PostMapping(value="/mock/{uuid}", params={"newMessage"})
public String newMessage(Model model, @RequestParam UUID clientUUID) {
MockedMessageDto mockedMessageDto = new MockedMessageDto(clientUUID, new LinkedHashMap<>());
populateModelVars(model, mockedMessageDto, true);
model.addAttribute("mockedMessageDto", mockedMessageDto);
return "mock";
}
@GetMapping("/mock/getMockedResponse")
@ResponseBody
public String showGetMockedResponse(MockedMessageDto mockedMessageDto) throws JsonProcessingException {
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(mockedMessageDto.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(mockedMessageDto.getMockedResponseId())));
return klausService.getMockedResponse(mockedMessageDto.getClientUUID(),
mockedMessageDto.getMockedResponseId()).toString();
}
@PostMapping(value = "/mock/{uuid}", params = {"addHeader"} )
public String addHeader(MockedMessageDto mockedMessageDto, @RequestParam String headerKey,
@RequestParam String headerValue, final Model model) {
populateModelVars(model, mockedMessageDto,false);
mockedMessageDto.getHttpHeaders().put(headerKey, headerValue);
return "mock";
}
@PostMapping(value="/mock/{uuid}", params={"removeHeader"})
public String removeHeader(MockedMessageDto mockedMessageDto, final HttpServletRequest req, final Model model) {
populateModelVars(model, mockedMessageDto,false);
mockedMessageDto.getHttpHeaders().remove(req.getParameter("removeHeader"));
return "mock";
}
@PostMapping(value="/mock/{uuid}", params={"updateMessage"})
public String updateMessage(final HttpServletRequest req, MockedMessageDto mockedMessageDto, final Model model) {
populateModelVars(model, mockedMessageDto, false);
model.addAttribute("mockedMessageDto", klausService.getMockedResponse(mockedMessageDto.getClientUUID(),
Integer.parseInt(req.getParameter("updateMessage"))));
model.addAttribute("canTest", "true");
return "mock";
}
@PostMapping(value="/mock/{uuid}", params={"removeMessage"})
public String removeMessage(MockedMessageDto mockedMessageDto, final HttpServletRequest req, final Model model) {
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "deleteMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(mockedMessageDto.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(Integer.parseInt(req.getParameter("removeMessage")))));
klausService.deleteMockedResponse(mockedMessageDto.getClientUUID(),
Integer.parseInt(req.getParameter("removeMessage")));
populateModelVars(model, mockedMessageDto, true);
return "mock";
}
//TODO: Remove multiplication.
//TODO: Add default message as template to resources
@GetMapping({"/mock/json", "/mock/json/{uuid}"})
@ResponseBody
public List<MockedMessageDto> getJsonList(final MockedMessageDto mockedMessageDto, final Model model,
@PathVariable(required = false) UUID uuid){
if(uuid == null) uuid = UUID.randomUUID();
List<MockedMessageDto> messages = klausService.getAllMockedResponses(uuid);
if(!(messages.size() > 0)) {
Map<String, String> headers = new HashMap<>();
headers.put("Keep-Alive", "timeout=60");
headers.put("Connection", "keep-alive");
headers.put("Date", LocalDateTime.now().toString());
MockedMessageDto msg = MockedMessageDto.builder()
.clientUUID(uuid)
.mockedResponseId(1)
.mediaType(MediaType.APPLICATION_XML_VALUE)
.messageBody("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<note>\n" +
" <to>Tove</to>\n" +
" <from>Jani</from>\n" +
" <heading>Reminder</heading>\n" +
" <body>Don't forget me this weekend!</body>\n" +
"</note>")
.httpHeaders(headers)
.httpStatus(200)
.build();
messages.add(msg);
headers = new HashMap<>();
headers.put("Keep-Alive", "timeout=60");
headers.put("Connection", "keep-alive");
headers.put("Date", LocalDateTime.now().toString());
msg = MockedMessageDto.builder()
.clientUUID(uuid)
.mockedResponseId(2)
.mediaType(MediaType.APPLICATION_XML_VALUE)
.messageBody("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<note>\n" +
" <to>Tove</to>\n" +
" <from>Jani</from>\n" +
" <heading>Reminder</heading>\n" +
" <body>Don't forget me this weekend!</body>\n" +
"</note>")
.httpHeaders(headers)
.httpStatus(404)
.build();
messages.add(msg);
headers = new HashMap<>();
headers.put("Keep-Alive", "timeout=60");
headers.put("Connection", "keep-alive");
headers.put("Date", LocalDateTime.now().toString());
msg = MockedMessageDto.builder()
.clientUUID(uuid)
.mockedResponseId(3)
.mediaType(MediaType.APPLICATION_XML_VALUE)
.messageBody("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<note>\n" +
" <to>Tove</to>\n" +
" <from>Jani</from>\n" +
" <heading>Reminder</heading>\n" +
" <body>Don't forget me this weekend!</body>\n" +
"</note>")
.httpHeaders(headers)
.httpStatus(500)
.build();
messages.add(msg);
}
return messages;
}
@SneakyThrows
@ModelAttribute("localhost")
public String localhost() {
return InetAddress.getLocalHost().getHostName();
}
@ModelAttribute("clientUUID")
public UUID clientUUID() {
return UUID.randomUUID();
}
//TODO: Remove
@Deprecated
private void getModelMockedMessageDto(Model model, MockedMessageDto mockedMessageDto) {
if (mockedMessageDto.getMockedResponseId() == null){
Map<String, String> headers = new HashMap<>();
headers.put("Keep-Alive", "timeout=60");
headers.put("Connection", "keep-alive");
headers.put("Date", LocalDateTime.now().toString());
globalMockedMessageDto = MockedMessageDto.builder()
.clientUUID(mockedMessageDto.getClientUUID())
.mockedResponseId(1)
.mediaType(MediaType.APPLICATION_XML_VALUE)
.messageBody("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<note>\n" +
" <to>Tove</to>\n" +
" <from>Jani</from>\n" +
" <heading>Reminder</heading>\n" +
" <body>Don't forget me this weekend!</body>\n" +
"</note>")
.httpHeaders(headers)
.httpStatus(200)
.build();
} else {
globalMockedMessageDto = mockedMessageDto;
}
model.addAttribute("mockedMessageDto", globalMockedMessageDto);
}
private void populateModelVars(Model model, MockedMessageDto mockedMessageDto, boolean updateList){
if (updateList){
globalMockedMessageDtoList.clear();
List<MockedMessageDto> mockedMessageDtoList = klausService.
getAllMockedResponses(mockedMessageDto.getClientUUID());
System.out.println(mockedMessageDtoList);
if (mockedMessageDtoList.size() > 0){
globalMockedMessageDtoList.addAll(mockedMessageDtoList);
}
}
model.addAttribute("mockedMessageDtoList", globalMockedMessageDtoList);
getModelMockedMessageDto(model, mockedMessageDto);
}
public static MockedMessageDto getGlobalMockedMessageDto() {
return globalMockedMessageDto;
}
}