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

package org.ros.chatto.service;

import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.ros.chatto.dto.ActiveUserDTO;
import org.ros.chatto.dto.UserRegistrationDTO;
import org.ros.chatto.model.ChatUser;
import org.ros.chatto.model.Role;
import org.ros.chatto.model.UserRole;
import org.ros.chatto.model.UserSession;
import org.ros.chatto.repository.UserRepository;
import org.ros.chatto.repository.UserRepositoryCustom;
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;

@Transactional
@Service
public class UserServiceImpl implements UserService {
	@Autowired
	private UserRepository userRepository;

	@Autowired
	private UserRoleRepository userRoleRepository;

	@Autowired
	private  PasswordEncoder passwordEncoder;

	@Autowired
	private RoleService roleService;

	@Autowired
	private UserRepositoryCustom userRepositoryCustom;

	@Autowired
	private UserSessionRepository userSessionRepository;


	@Override
	public void saveChatUser(ChatUser user) {
		ChatUser changedUser = userRepository.save(user);
		UserRole userRole = new UserRole();
		userRole.setRole(roleService.getRole("USER"));
		userRole.setUser(changedUser);
		userRoleRepository.save(userRole);
	}

	@Override
	public void registerUser(UserRegistrationDTO userRegistrationDTO) {
		ChatUser user = new ChatUser();
		user.setUserName(userRegistrationDTO.getUserName());
		user.setPassword(passwordEncoder.encode(userRegistrationDTO.getPassword()));
		ChatUser changedUser = userRepository.save(user);
		UserRole userRole = new UserRole();
		Role role = roleService.getRole("USER");
		userRole.setRole(role);
		userRole.setUser(changedUser);
		System.out.println(role.getRoleId());
		System.out.println(changedUser.getUserID());
		userRoleRepository.save(userRole);
	}

	@Override
	@Transactional(readOnly = true)
	public List<String> findAllOtherUsers(String userName) {
		return userRepository.findAllOtherUserNames(userName);
	}

	@Transactional(readOnly = true)
	@Override
	public List<String> getAllRegularUsers() {
		return userRoleRepository.getAllRegularUser();
	}

	@Transactional(readOnly = true)
	public List<ActiveUserDTO> getOtherActiveUsers(String userName) {
		List<String> userList = findAllOtherUsers(userName);
		
		List<UserSession> userSessionsList = userSessionRepository.findAllUserSessions();
		Map<String, UserSession> lastActiveMap = convertToMap(userSessionsList);
		
		List<ActiveUserDTO> activeUserDTOs = new ArrayList<ActiveUserDTO>();
		userList.forEach(u -> {
			ActiveUserDTO activeUserDTO = new ActiveUserDTO();
			UserSession  us = lastActiveMap.get(u);
			
			activeUserDTO.setUserName(u);
			activeUserDTO.setOnline(false);
			activeUserDTO.setLastActive(null);
			if(us != null)
			{
				activeUserDTO.setOnline(us.isOnline());
				activeUserDTO.setLastActive(toLastActiveString(us.getTimeStamp()));
			}
			
			activeUserDTOs.add(activeUserDTO);
		});
			
		return activeUserDTOs;
	}

	@Transactional(readOnly = true)
	@Override
	public ChatUser findByUserName(String userName) {
		return userRepository.findByUserName(userName);
	}

	private Map<String, UserSession> convertToMap(List<UserSession> userSessionList) {
		Map<String, UserSession> userMap = new HashMap<>();
		userSessionList.forEach(us -> {
			userMap.put(us.getUser().getUserName(), us);
		});
		return userMap;
	}

	private String toLastActiveString(Instant lastActive) {
		if (lastActive == null)
			return null;
		Duration duration = Duration.between(lastActive, Instant.now());
		long hours = duration.toHours();
		long minutes = duration.toMinutes();
		long days = duration.toDays();
		// @formatter:off
		if(minutes < 60) 
		{
			return String.format("%d minutes ago", minutes);
		}
		else 
		{
			if(hours < 24) 
			{
				return String.format("%d hours ago", hours);
			}
			else 
			{
				if(days < 30)
				{
					return String.format("%d days ago", days);
				}
				else if(days < 366)
				{
					return String.format("%d months ago", days/30);
				}
				else {
					return String.format("%d years ago", days/365);
				}
			}
		}
		// @formatter:on

	}
}