nova/Chatto
1
0
Fork 0
Code Issues 7 Pull Requests Releases Wiki Activity

switched to constructor injection

Browse Source
This commit is contained in:
Rohan Sircar 2019-12-12 12:18:19 +05:30
parent 53d89dc36f
commit 1a15743dcd
4 changed files with 50 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
chatto/src/main/java/org/ros/chatto/controller/ChatMessageController.java
View File

@ -17,7 +17,6 @@ import org.ros.chatto.error.ErrorModel;
import org.ros.chatto.error.ErrorResponse;
import org.ros.chatto.service.ChatService;
import org.ros.chatto.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
@ -27,84 +26,59 @@ import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import lombok.RequiredArgsConstructor;
@RestController
@RequestMapping("/api/chat")
@RequiredArgsConstructor
public class ChatMessageController {
@Autowired
private ChatService chatService;
@Autowired
private UserService userService;
private final ChatService chatService;
private final UserService userService;
@PostMapping(value = "/post/message", consumes = { "application/json" })
@ResponseBody
public ResponseEntity<?> newMessage(@RequestBody @Valid ChatMessageDTO chatMessageDTO, BindingResult bindingResult,
Principal principal) {
public ResponseEntity<?> newMessage(@RequestBody @Valid final ChatMessageDTO chatMessageDTO,
final BindingResult bindingResult, final Principal principal) {
if (bindingResult.hasErrors()) {
// return new ResponseEntity<List<FieldError>>(bindingResult.getFieldErrors(),HttpStatus.BAD_REQUEST);
return new ResponseEntity<ErrorResponse>(handleException(bindingResult), HttpStatus.BAD_REQUEST);
return new ResponseEntity<ErrorResponse>(handleValidationErrors(bindingResult), HttpStatus.BAD_REQUEST);
}
MessageCipherDTO messageCipher = chatMessageDTO.getMessageCipher();
String fromUser = principal.getName();
String toUser = chatMessageDTO.getToUser();
final MessageCipherDTO messageCipher = chatMessageDTO.getMessageCipher();
final String fromUser = principal.getName();
final String toUser = chatMessageDTO.getToUser();
System.out.println("Message cipher = " + messageCipher);
chatMessageDTO = chatService.saveNewMessage(fromUser, toUser, messageCipher);
return new ResponseEntity<ChatMessageDTO>(chatMessageDTO, HttpStatus.CREATED);
final ChatMessageDTO chatMessageDTOSaved = chatService.createMessage(fromUser, toUser, messageCipher);
return new ResponseEntity<ChatMessageDTO>(chatMessageDTOSaved, HttpStatus.CREATED);
}
/**
* Method that check against {@code @Valid} Objects passed to controller
* endpoints
*
* @param exception
* @return a {@code ErrorResponse}
* @see com.aroussi.util.validation.ErrorResponse
*/
// @ExceptionHandler(value = MethodArgumentNotValidException.class)
// @ResponseStatus(HttpStatus.BAD_REQUEST)
// public ErrorResponse handleException(MethodArgumentNotValidException exception) {
//
// List<ErrorModel> errorMessages = exception.getBindingResult().getFieldErrors().stream()
// .map(err -> new ErrorModel(err.getField(), err.getRejectedValue(), err.getDefaultMessage())).distinct()
// .collect(Collectors.toList());
// return ErrorResponse.builder().errorMessage(errorMessages).build();
// }
//
// @ExceptionHandler(value = MethodArgumentNotValidException.class)
// @ResponseStatus(HttpStatus.BAD_REQUEST)
public ErrorResponse handleException(BindingResult bindingResult) {
private ErrorResponse handleValidationErrors(final BindingResult bindingResult) {
List<ErrorModel> errorMessages = bindingResult.getFieldErrors().stream()
final List<ErrorModel> errorMessages = bindingResult.getFieldErrors().stream()
.map(err -> new ErrorModel(err.getField(), err.getRejectedValue(), err.getDefaultMessage())).distinct()
.collect(Collectors.toList());
return ErrorResponse.builder().errorMessage(errorMessages).build();
}
@GetMapping(value = "/get/messages/{userName}")
@ResponseBody
public List<ChatMessageDTO> sendAllMessages(@PathVariable String userName, Principal principal) {
List<ChatMessageDTO> chatMessageDTOs = chatService.getAllMessages(principal.getName(), userName);
public List<ChatMessageDTO> getAllMessages(@PathVariable final String userName, final Principal principal) {
final List<ChatMessageDTO> chatMessageDTOs = chatService.getAllMessages(principal.getName(), userName);
return chatMessageDTOs;
}
@GetMapping(value = "/get/messages/{userName}", params = { "page", "size" })
@ResponseBody
public List<ChatMessageDTO> findPaginated(@RequestParam("page") int page, @RequestParam("size") int size,
@PathVariable String userName, Principal principal) {
List<ChatMessageDTO> chatMessageDTOs = chatService.getMessagePage(principal.getName(), userName, page, size);
public List<ChatMessageDTO> findPaginated(@RequestParam("page") final int page,
@RequestParam("size") final int size, @PathVariable final String userName, final Principal principal) {
final List<ChatMessageDTO> chatMessageDTOs = chatService.getMessagePage(principal.getName(), userName, page,
size);
return chatMessageDTOs;
}
@GetMapping(value = "/get/messages/{userName}/{lastMessageTime}")
@ResponseBody
public List<ChatMessageDTO> sendNewMessages(@PathVariable String userName, @PathVariable String lastMessageTime,
Principal principal) {
public List<ChatMessageDTO> sendNewMessages(@PathVariable final String userName,
@PathVariable final String lastMessageTime, final Principal principal) {
System.out.println("Last message time = " + lastMessageTime);
DateTimeFormatter formatter = new DateTimeFormatterBuilder()
final DateTimeFormatter formatter = new DateTimeFormatterBuilder()
// date/time
.append(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
// offset (hh:mm - "+00:00" when it's zero)
@ -115,19 +89,19 @@ public class ChatMessageController {
.optionalStart().appendOffset("+HH", "Z").optionalEnd()
// create formatter
.toFormatter();
Date date = Date.from(OffsetDateTime.parse(lastMessageTime, formatter).toInstant());
final Date date = Date.from(OffsetDateTime.parse(lastMessageTime, formatter).toInstant());
List<ChatMessageDTO> chatMessageDTOs = chatService.getNewMessages(principal.getName(), userName, date);
final List<ChatMessageDTO> chatMessageDTOs = chatService.getNewMessages(principal.getName(), userName, date);
return chatMessageDTOs;
}
@GetMapping("/get/users")
public List<String> getAllOtherUsers(Principal principal) {
public List<String> getAllOtherUsers(final Principal principal) {
return userService.findAllOtherUsers(principal.getName());
}
@GetMapping("/get/active-users")
public List<ActiveUserDTO> getAllOtherActiveUsers(Principal principal) {
public List<ActiveUserDTO> getAllOtherActiveUsers(final Principal principal) {
return userService.getOtherActiveUsers(principal.getName());
}
@ -137,11 +111,13 @@ public class ChatMessageController {
}
}
//public ResponseEntity<List<ChatMessage>> getMessages(@PathVariable String userName, Principal principal) {
////List<ChatMessage> chatMessages = chatMessageRepository.getAllMessages(principal.getName(), userName);
// public ResponseEntity<List<ChatMessage>> getMessages(@PathVariable String
// userName, Principal principal) {
//// List<ChatMessage> chatMessages =
// chatMessageRepository.getAllMessages(principal.getName(), userName);
//
//// return posts.stream()
//// .map(post -> convertToDto(post))
//// .collect(Collectors.toList());
//return new ResponseEntity<List<ChatMessage>>(chatMessages, HttpStatus.OK);
//}
// return new ResponseEntity<List<ChatMessage>>(chatMessages, HttpStatus.OK);
// }

10
chatto/src/main/java/org/ros/chatto/service/ChatService.java
View File

@ -3,25 +3,17 @@ package org.ros.chatto.service;
import java.util.Date;
import java.util.List;
import javax.validation.Valid;
import org.ros.chatto.dto.ChatMessageDTO;
import org.ros.chatto.dto.MessageCipherDTO;
import org.ros.chatto.dto.ReencryptionDTO;
import org.springframework.data.domain.PageRequest;
public interface ChatService {
public @Valid ChatMessageDTO saveNewMessage(String fromUser, String toUser, MessageCipherDTO messageCipherDTO);
public ChatMessageDTO createMessage(String fromUser, String toUser, MessageCipherDTO messageCipherDTO);
public List<ChatMessageDTO> getAllMessages(String fromUser, String toUser);
public List<ChatMessageDTO> getMessagePage(String fromUser, String toUser, int page, int size);
public List<ChatMessageDTO> getNewMessages(String fromUser, String toUser, Date lastMessageTime);
public void reencryptMessages(List<ReencryptionDTO> reencryptionDTOs);
public List<ReencryptionDTO> getAllMessagesForReencryption(String fromUser, String toUser);
public List<ChatMessageDTO> getAllMessages(String name, String userName, PageRequest pageRequest);
}

18
chatto/src/main/java/org/ros/chatto/service/ChatServiceImpl.java
View File

@ -13,25 +13,23 @@ import org.ros.chatto.model.MessageCipher;
import org.ros.chatto.repository.ChatMessageRepository;
import org.ros.chatto.repository.MessageCipherRepository;
import org.ros.chatto.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import lombok.RequiredArgsConstructor;
@Service
@Transactional
@RequiredArgsConstructor
public class ChatServiceImpl implements ChatService {
@Autowired
UserRepository userRepository;
@Autowired
MessageCipherRepository messageCipherRepository;
@Autowired
ChatMessageRepository chatMessageRepository;
@Autowired
MyConversionService myConversionService;
private final UserRepository userRepository;
private final MessageCipherRepository messageCipherRepository;
private final ChatMessageRepository chatMessageRepository;
private final MyConversionService myConversionService;
public ChatMessageDTO saveNewMessage(final String fromUserName, final String toUserName,
public ChatMessageDTO createMessage(final String fromUserName, final String toUserName,
final MessageCipherDTO messageCipherDTO) {
MessageCipher messageCipher = myConversionService.convertToMessageCipher(messageCipherDTO);

15
chatto/src/main/java/org/ros/chatto/service/UserServiceImpl.java
View File

@ -17,13 +17,15 @@ import org.ros.chatto.repository.RoleRepository;
import org.ros.chatto.repository.UserRepository;
import org.ros.chatto.repository.UserRoleRepository;
import org.ros.chatto.repository.UserSessionRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import lombok.RequiredArgsConstructor;
@Transactional
@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
private final UserRepository userRepository;
@ -35,17 +37,6 @@ public class UserServiceImpl implements UserService {
private final UserSessionRepository userSessionRepository;
public UserServiceImpl(@Autowired final UserRepository userRepository,
@Autowired final UserRoleRepository userRoleRepository, @Autowired final PasswordEncoder passwordEncoder,
@Autowired final RoleRepository roleRepository,
@Autowired final UserSessionRepository userSessionRepository) {
this.userRepository = userRepository;
this.userRoleRepository = userRoleRepository;
this.passwordEncoder = passwordEncoder;
this.roleRepository = roleRepository;
this.userSessionRepository = userSessionRepository;
}
@Override
public UserRole registerUser(final UserRegistrationDTO userRegistrationDTO) {
final ChatUser user = new ChatUser();