Chatto/chatto/src/main/java/org/ros/chatto/service/ChatServiceImpl.java

package org.ros.chatto.service;

import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

import org.ros.chatto.dto.ChatMessageDTO;
import org.ros.chatto.dto.MessageCipherDTO;
import org.ros.chatto.dto.ReencryptionDTO;
import org.ros.chatto.model.ChatMessage;
import org.ros.chatto.model.ChatUser;
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.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 {

	private final UserRepository userRepository;
	private final MessageCipherRepository messageCipherRepository;
	private final ChatMessageRepository chatMessageRepository;
	private final MyConversionService myConversionService;

	public ChatMessageDTO createMessage(final String fromUserName, final String toUserName,
			final MessageCipherDTO messageCipherDTO) {

		MessageCipher messageCipher = myConversionService.convertToMessageCipher(messageCipherDTO);
		final ChatUser fromUser = userRepository.findByUserName(fromUserName);
		final ChatUser toUser = userRepository.findByUserName(toUserName);

		ChatMessage chatMessage = new ChatMessage();
		messageCipher = messageCipherRepository.save(messageCipher);
		chatMessage.setMessageCipher(messageCipher);
		chatMessage.setFromUser(fromUser);
		chatMessage.setToUser(toUser);

		chatMessage = chatMessageRepository.save(chatMessage);
		return myConversionService.convertToChatMessageDTO(chatMessage);

	}

	@Override
	@Transactional(readOnly = true)
	public List<ChatMessageDTO> getAllMessages(final String fromUser, final String toUser) {
		final List<ChatMessage> chatMessages = chatMessageRepository.getAllMessages(fromUser, toUser);
		final List<ChatMessageDTO> chatMessageDTOs = myConversionService.convertToChatMessageDTOs(chatMessages);
		return chatMessageDTOs;
	}

	@Override
	@Transactional(readOnly = true)
	public List<ReencryptionDTO> getAllMessagesForReencryption(final String fromUser, final String toUser) {
		return myConversionService.convertToReencryptionDTOs(chatMessageRepository.getAllMessages(fromUser, toUser));
	}

	@Override
	@Transactional(readOnly = true)
	public List<ChatMessageDTO> getMessagePage(final String fromUser, final String toUser, final int page,
			final int size) {
		// Sort sort = Sort
		// Page<ChatMessage> chatMessages =
		// chatMessageRepository.getAllMessages(fromUser, toUser,PageRequest.of(page,
		// size));
		// List<ChatMessageDTO> chatMessageDTOs =
		// myConversionService.convertToChatMessageDTOs(chatMessages);
		// return chatMessageDTOs;
		return myConversionService.convertToChatMessageDTOs(
				chatMessageRepository.getAllMessages(fromUser, toUser, PageRequest.of(page, size)));
	}

	@Override
	@Transactional(readOnly = true)
	public List<ChatMessageDTO> getNewMessages(final String fromUser, final String toUser, final Date lastMessageTime) {
		final List<ChatMessage> chatMessages = chatMessageRepository.getNewMessages(fromUser, toUser, lastMessageTime);
		// List<ChatMessageDTO> chatMessageDTOs
		return myConversionService.convertToChatMessageDTOs(chatMessages);
	}

	@Override
	public void reencryptMessages(final List<ReencryptionDTO> reencryptionDTOs) {
		final List<MessageCipher> messageCiphers = reencryptionDTOs.stream()
				.map(reencryptionDTO -> reencryptionDTO.getMessageCipher()).collect(Collectors.toList());
		messageCipherRepository.saveAll(messageCiphers);
	}

	@Override
	public List<ChatMessageDTO> getAllMessages(final String name, final String userName,
			final PageRequest pageRequest) {
		// TODO Auto-generated method stub
		return null;
	}
}