Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import java.util.function.Predicate;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import com.spice.profitmandi.common.ResponseCodeHolder;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.common.model.UserInfo;

import com.spice.profitmandi.common.util.JWTUtil;

import com.spice.profitmandi.dao.entity.Permission;

import com.spice.profitmandi.dao.entity.Role;

import com.spice.profitmandi.dao.entity.User;

import com.spice.profitmandi.dao.entity.UserRole;

import com.spice.profitmandi.dao.enumuration.RoleType;

import com.spice.profitmandi.dao.repository.PermissionRepository;

import com.spice.profitmandi.dao.repository.RoleRepository;

import com.spice.profitmandi.dao.repository.UserRepository;

import com.spice.profitmandi.dao.repository.UserRoleRepository;

import com.spice.profitmandi.web.enumuration.UserStatus;

import com.spice.profitmandi.web.model.ProfitMandiResponse;

import com.spice.profitmandi.web.model.ResponseStatus;

import com.spice.profitmandi.web.processor.GoogleLoginProcessor;

import com.spice.profitmandi.web.req.UserAddRoleRequest;

import com.spice.profitmandi.web.req.UserRequest;

import com.spice.profitmandi.web.util.ResponseSender;

import io.swagger.annotations.ApiImplicitParam;

import io.swagger.annotations.ApiImplicitParams;

/**

 * @author ashikali

 *

 */

@Controller

public class UserController {

	@Autowired

	ResponseSender<?> responseSender;

	private static final Logger LOGGER = LoggerFactory.getLogger(UserController.class);

	@Value("${admin.token}")

	private String validAdminToken;

	@Autowired

	UserRepository userRepository;

	@Autowired

	RoleRepository roleRepository;

	@Autowired

	UserRoleRepository userRoleRepository;

	@Autowired

	PermissionRepository permissionRepository;

	@Autowired

	GoogleLoginProcessor googleLoginProcessor;

	@SuppressWarnings("unchecked")

	@RequestMapping(value = ProfitMandiConstants.URL_USER_GOOGLE_LOGIN, method = RequestMethod.POST)

	public ResponseEntity<?> googleLogin(HttpServletRequest request) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		final Map<String, Object> googleLoginMap = (Map<String, Object>) request

				.getAttribute(ProfitMandiConstants.GOOGLE_LOGIN_MAP);

		request.removeAttribute(ProfitMandiConstants.GOOGLE_LOGIN_MAP);

		try {

			return responseSender.ok(googleLoginProcessor.process(googleLoginMap));

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("ProfitMandi error: ", profitMandiBusinessException);

			return responseSender.badRequest(profitMandiBusinessException);

		}

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_TOKEN_IS_EXPIRED, method = RequestMethod.GET)

	public ResponseEntity<?> tokenIsExpired(HttpServletRequest request, @RequestParam(name = "token") String token) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		try {

			return responseSender.ok(JWTUtil.isExpired(token));

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("ProfitMandi error: ", profitMandiBusinessException);

			return responseSender.badRequest(profitMandiBusinessException);

		}

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_TOKEN_INFO, method = RequestMethod.GET)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header") })

	public ResponseEntity<?> tokenInfo(HttpServletRequest request) throws Throwable {

		Map<String, Object> responseMap = new HashMap<>();

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

		if (userInfo.getEmail() == null) {

			User user = userRepository.selectById(userInfo.getUserId());

			responseMap.put(ProfitMandiConstants.EMAIL_ID, user.getEmailId());

			responseMap.put(ProfitMandiConstants.USER_ID, user.getId());

			// if user is retailer

			if (user.getRoles().stream().anyMatch(new Predicate<Role>() {

				@Override

				public boolean test(Role t) {

					return t.getType().equals(RoleType.RETAILER);

				}

			})) {

				// TODO: This should be from retailer Table

				// if retailer is activated and migrated is 0 then verified

				// retailer

				// if retailer is not activated and and migrated is 0 then not

				// verified retailer

				// if retailer is activated and migrated is 1 then retailer is

				// retailer.

				if (user.isActivated()) {

					responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.VERIFIED_RETAILER.getValue());

				} else {

					responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.NOT_VERIFIED_RETAILER.getValue());

				}

			} else if (user.getRoles().stream().anyMatch(new Predicate<Role>() {

				@Override

				public boolean test(Role t) {

					return t.getType().equals(RoleType.USER);

				}

			})) {

				responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.REGISTERED.getValue());

			}

		} else {

			responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.NOT_REGISTERED.getValue());

			responseMap.put(ProfitMandiConstants.EMAIL_ID, userInfo.getEmail());

		}

		return responseSender.ok(responseMap);

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER, method = RequestMethod.POST)

	public ResponseEntity<?> createUser(HttpServletRequest request, @RequestBody UserRequest userRequest) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		User user = new User();

		user.setFirstName(userRequest.getFirstName());

		user.setLastName(userRequest.getLastName());

		user.setCity(userRequest.getCity());

		user.setPinCode(Integer.valueOf(userRequest.getPinCode()));

		user.setEmailId(userRequest.getEmailId());

		user.setUsername("");

		user.setPassword("");

		user.setMobile_verified(false);

		user.setReferral_url("");

		user.setGroup_id(1);

		user.setStatus(0);

		user.setActivated(false);

		try {

			user.setCreateTimestamp(LocalDateTime.now());

			user.setUpdateTimestamp(LocalDateTime.now());

			userRepository.persist(user);

			return responseSender.ok(ResponseCodeHolder.getMessage("USR_OK_1000"));

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("ProfitMandi error: ", profitMandiBusinessException);

			return responseSender.badRequest(profitMandiBusinessException);

		}

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_ALL, method = RequestMethod.GET)

	public ResponseEntity<?> getAll(HttpServletRequest request) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		return responseSender.ok(userRepository.selectAll());

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_ID, method = RequestMethod.GET)

	public ResponseEntity<?> getById(HttpServletRequest request, @RequestParam(name = "id") int id) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		try {

			return responseSender.ok(userRepository.selectById(id));

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("ProfitMandi error: ", profitMandiBusinessException);

			return responseSender.badRequest(profitMandiBusinessException);

		}

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_MOBILE_NUMBER, method = RequestMethod.GET)

	public ResponseEntity<?> getByMobileNumber(HttpServletRequest request,

			@RequestParam(name = "mobileNumber") String mobileNumber) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		try {

			return responseSender.ok(userRepository.selectByMobileNumber(mobileNumber));

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("ProfitMandi error: ", profitMandiBusinessException);

			return responseSender.badRequest(profitMandiBusinessException);

		}

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_IS_EXIST_MOBILE_NUMBER, method = RequestMethod.GET)

	public ResponseEntity<?> isMobileNumberExist(HttpServletRequest request,

			@RequestParam(name = "mobileNumber") String mobileNumber) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		return responseSender.ok(userRepository.isExistByMobileNumber(mobileNumber));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_EMAIL_ID, method = RequestMethod.GET)

	public ResponseEntity<?> getByEmailId(HttpServletRequest request, @RequestParam(name = "emailId") String emailId) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		try {

			return responseSender.ok(userRepository.selectByEmailId(emailId));

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("ProfitMandi error: ", profitMandiBusinessException);

			return responseSender.badRequest(profitMandiBusinessException);

		}

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_ROLE_ADD, method = RequestMethod.POST)

	public ResponseEntity<?> addRole(HttpServletRequest request, @RequestBody UserAddRoleRequest userAddRoleRequest) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		try {

			User user = userRepository.selectById(userAddRoleRequest.getUserId());

			Role role = null;

			try {

				role = roleRepository.selectByNameAndType(userAddRoleRequest.getRole().getName(),

						userAddRoleRequest.getRole().getType());

			} catch (ProfitMandiBusinessException profitMandiBusinessException) {

				role = new Role();

				role.setName(userAddRoleRequest.getRole().getName());

				role.setType(userAddRoleRequest.getRole().getType());

				roleRepository.persist(role);

			}

			Permission permission = new Permission();

			permission.setType(userAddRoleRequest.getRole().getPermissionType());

			permission.setRoleId(role.getId());

			permissionRepository.persist(permission);

			UserRole userRole = new UserRole();

			userRole.setRoleId(role.getId());

			userRole.setUserId(user.getId());

			userRoleRepository.persist(userRole);

			return responseSender.ok("");

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("ProfitMandi error: ", profitMandiBusinessException);

			return responseSender.badRequest(profitMandiBusinessException);

		}

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_ROLE_REMOVE, method = RequestMethod.DELETE)

	public ResponseEntity<?> removeRole(HttpServletRequest request, @RequestParam(name = "roleId") int roleId,

			@RequestParam(name = "userId") int userId) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		try {

			roleRepository.selectById(roleId);

			userRepository.selectById(userId);

			userRoleRepository.deleteByUserAndRoleId(userId, roleId);

			permissionRepository.deleteByRoleId(roleId);

			return responseSender.ok("");

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("ProfitMandi error: ", profitMandiBusinessException);

			return responseSender.badRequest(profitMandiBusinessException);

		}

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_ROLE_ALL, method = RequestMethod.GET)

	public ResponseEntity<?> getAllRoles(HttpServletRequest request, @RequestParam(name = "id") int id) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		return responseSender.ok(userRoleRepository.selectRolesByUserId(id));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_ADMIN_TOKEN, method = RequestMethod.POST)

	public ResponseEntity<?> getAdminToken(HttpServletRequest request,

			@RequestParam(name = "adminToken") String adminToken, @RequestParam(name = "emailId") String emailId) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		if (!adminToken.equals(validAdminToken)) {

			final ProfitMandiResponse<?> profitMandiResponse = new ProfitMandiResponse<>(LocalDateTime.now(),

					request.getRequestURL().toString(), HttpStatus.FORBIDDEN.toString(), HttpStatus.FORBIDDEN,

					ResponseStatus.FAILURE, null);

			return new ResponseEntity<>(profitMandiResponse, HttpStatus.FORBIDDEN);

		}

		Map<String, Object> responseMap = new HashMap<>(2);

		try {

			User user = userRepository.selectByEmailId(emailId);

			Set<Role> roles = user.getRoles();

			String[] roleTypes = new String[roles.size()];

			int index = 0;

			for (Role role : roles) {

				roleTypes[index++] = role.getType().toString();

			}

			responseMap.put(ProfitMandiConstants.TOKEN, JWTUtil.create(user.getId(), roleTypes));

			responseMap.put(ProfitMandiConstants.REGISTERED, true);

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			responseMap.put(ProfitMandiConstants.TOKEN, JWTUtil.create(emailId));

			responseMap.put(ProfitMandiConstants.REGISTERED, false);

		}

		return responseSender.ok(responseMap);

	}

}