Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import org.apache.http.conn.HttpHostConnectException;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

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

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

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.eclipsesource.json.Json;

import com.eclipsesource.json.JsonArray;

import com.eclipsesource.json.JsonObject;

import com.eclipsesource.json.JsonValue;

import com.google.gson.Gson;

import com.spice.profitmandi.common.ResponseCodeHolder;

import com.spice.profitmandi.common.enumuration.SchemeType;

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

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

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

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

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

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

import com.spice.profitmandi.common.web.client.RestClient;

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

import com.spice.profitmandi.dao.entity.dtr.Retailer;

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

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

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

import com.spice.profitmandi.dao.entity.user.Address;

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

import com.spice.profitmandi.dao.model.UserCart;

import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;

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

import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;

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

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

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.service.AuthService;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.user.UserService;

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

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

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

import com.spice.profitmandi.web.res.Notification;

import io.swagger.annotations.ApiImplicitParam;

import io.swagger.annotations.ApiImplicitParams;

/**

 * @author ashikali

 *

 */

@Controller

@Transactional(rollbackFor=Throwable.class)

public class UserController {

	@Autowired

	private ResponseSender<?> responseSender;

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

	@Value("${notifications.api.host}")

	private String nodeHost;

	@Value("${notifications.api.port}")

	private int nodePort;

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

	private String validAdminToken;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	private com.spice.profitmandi.dao.repository.user.UserRepository userUserRepository;

	@Autowired

	private RetailerRepository retailerRepository;

	@Autowired

	private UserRoleRepository userRoleRepository;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	private AuthService authService;

	@Autowired

	private AddressRepository addressRepository;

	@Autowired

	private GoogleLoginProcessor googleLoginProcessor;

	@Autowired

	private UserService userService;

	@Autowired

	private RestClient restClient;

	@Autowired

	private RoleManager roleManager;

	@Autowired

	private RoleRepository roleRepository;

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

	public ResponseEntity<?> googleLogin(HttpServletRequest request, @RequestBody GoogleLoginRequest googleLoginRequest) throws ProfitMandiBusinessException{

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

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

	}

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

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

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

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

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_DETAIL_BY_TOKEN, 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<>();

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

		User user = null;

		if (userInfo.getUserId() > -1) {

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

			if(!user.getEmailId().equalsIgnoreCase(userInfo.getEmail())) {

				String userName = null;

				if(user.getSecondryEmailId()!=null && user.getSecondryEmailId().equals(userInfo.getEmail())) {

					userName = user.getFirstName() + " " + user.getLastName();

				} else {

					userName = authService.getNameByEmailId(userInfo.getEmail());

				}

				responseMap.put(ProfitMandiConstants.USER_ID, userInfo.getUserId());

				responseMap.put(ProfitMandiConstants.USER_NAME, userName);

				responseMap.put(ProfitMandiConstants.USER_STATUS, "fofoAssociate");

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

				return responseSender.ok(responseMap);

			}

		} else {

			try {

				user = userRepository.selectByEmailId(userInfo.getEmail());

			} catch (ProfitMandiBusinessException e1) {

			}

			if(user == null){

				try {

					user = userRepository.selectBySecondryEmailId(userInfo.getEmail());

				} catch (ProfitMandiBusinessException e1) {

					LOGGER.info("Uneregistered user", userInfo.getEmail());

				}

			}

		}

		if (user != null) {

			int retailerId = userAccountRepository.selectRetailerIdByUserId(user.getId());

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

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

			responseMap.put(ProfitMandiConstants.USER_NAME, user.getFirstName() + " " + user.getLastName());

			List<Integer> roleIds = userRoleRepository.selectRoleIdsByUserId(user.getId());

			//LOGGER.info("userRoles {} ", userRoles);

			// generate new token if roles have been updated

			if (userInfo.getRoleIds() == null || roleIds.size() != userInfo.getRoleIds().size()) {

				String[] roleIdStrings = new String[roleIds.size()];

				int index = 0;

				for (int roleId : roleIds) {

					roleIdStrings[index++] = String.valueOf(roleId);

				}

				String newToken = JWTUtil.create(user.getId(), retailerId, roleIdStrings);

				responseMap.put("newAuthToken", newToken);

			}

			// if user is retailer

			Set<Integer> roleIdsSet = new HashSet<Integer>(roleIds);

			if (roleManager.isRetailer(roleIdsSet)) {

				UserCart uc = userAccountRepository.getUserCart(userInfo.getUserId());

				Retailer retailer = retailerRepository.selectById(uc.getUserId());

				com.spice.profitmandi.dao.entity.user.User saholicUser = userUserRepository.selectById(uc.getUserId());

				if(saholicUser.getAddressId() != null){

					Address address = addressRepository.selectById(saholicUser.getAddressId());

					responseMap.put(ProfitMandiConstants.ADDRESS, address);

				}

				// if retailer is activated 1 then verified retailer

				// else if migrated is 1 then old retailer

				// also lets incoporte old process i.e is user is activated then also retailer is verified retailer

				// else retailer is not verifed

				if (retailer.isActive() || user.isActivated()) {

					if (roleManager.isPartner(roleIdsSet)) {

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

					} else {

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

					}

				} else if (retailer.isMigrated()) {

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

				} else {

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

				}

			} else if (roleManager.isUser(roleIdsSet)) {

				responseMap.put("userInfo", getRegisteredUserInfo(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);

	}

	private RegisteredUserInfo getRegisteredUserInfo(User user) throws Throwable {

		RegisteredUserInfo ri = new RegisteredUserInfo();

		ri.setCity(user.getCity());

		ri.setFirstName(user.getFirstName());

		ri.setLastName(user.getLastName());

		ri.setPhone(user.getMobileNumber());

		ri.setPinCode(user.getPinCode());

		ri.setState(user.getState());

		return ri;

	}

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

	@ApiImplicitParams({

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

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

			throws ProfitMandiBusinessException {

		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.setState(userRequest.getState());

		user.setMobileNumber(userRequest.getMobieNumber());

		user.setEmailId(userRequest.getEmailId());

		user.setUsername("");

		user.setPassword("");

		user.setMobile_verified(false);

		user.setReferral_url("");

		user.setGroup_id(1);

		user.setStatus(1);

		user.setActivated(false);

		user.setCreateTimestamp(LocalDateTime.now());

		user.setUpdateTimestamp(LocalDateTime.now());

		userRepository.persist(user);

		Role role = roleRepository.selectByName(RoleType.USER.toString());

		UserRole userRole = new UserRole();

		userRole.setRoleId(role.getId());

		userRole.setUserId(user.getId());

		userRoleRepository.persist(userRole);

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

	}

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

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

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

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

	}

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

	public ResponseEntity<?> getByMobileNumber(HttpServletRequest request,

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

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

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

	}

	@ApiImplicitParams({

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

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

	public ResponseEntity<?> activateUser(HttpServletRequest request,

			@RequestParam(name = "activationCode") String activationCode) throws Throwable {

		int userId = (int) request.getAttribute("userId");

		UserCart uc = userAccountRepository.getUserCart(userId);

		return responseSender.ok(userService.updateActivation(userId, uc.getUserId(), activationCode));

	}

	@ApiImplicitParams({

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

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

	public ResponseEntity<?> getNofitications(HttpServletRequest request,

			@RequestParam(name = "androidId") String androidId, @RequestParam(name = "pageNumber") int pageNumber,

			@RequestParam(name = "pageSize") int pageSize) throws ProfitMandiBusinessException{

		int userId = (int) request.getAttribute("userId");

		String restResponse = null;

		Map<String, String> params = new HashMap<>();

		String uri = "/getAllNotifications";

		params.put("user_id", userId + "");

		params.put("android_id", androidId);

		params.put("limit", pageSize + "");

		params.put("offset", "" + ((pageNumber - 1) * pageSize));

		try {

			restResponse = restClient.get(SchemeType.HTTP, nodeHost, nodePort, uri, params);

		} catch (HttpHostConnectException e) {

			throw new ProfitMandiBusinessException("", "", "Could not Connect to host");

		}

		JsonArray result_json = Json.parse(restResponse).asArray();

		List<Notification> notifications = new ArrayList<>();

		for (JsonValue j : result_json) {

			notifications.add(toNotifiaction(j.asObject()));

		}

		return responseSender.ok(notifications);

	}

	private Notification toNotifiaction(JsonObject jsonObject) {

		Notification n = (Notification) (new Gson().fromJson(jsonObject.toString(), Notification.class));

		if (n.getStatus().equals("opened") || n.getStatus().equals("referrer") || n.getStatus().equals("seen")) {

			n.setSeen(true);

		}

		return n;

	}

	@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) throws ProfitMandiBusinessException{

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

		User user = null;

		try{

			user = userRepository.selectByEmailId(emailId);

		}catch(ProfitMandiBusinessException profitMandiBusinessException){

			user = userRepository.selectBySecondryEmailId(emailId);

		}

		return responseSender.ok(user);

	}

	@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));

	}

	@ApiImplicitParams({

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

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

	public ResponseEntity<?> getSecondryEmailAndStoreCode(HttpServletRequest request) throws ProfitMandiBusinessException{

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

		int userId = (int) request.getAttribute(ProfitMandiConstants.USER_ID);

		return responseSender.ok(userService.getEmailsAndFofoStoreCodeByUserId(userId));

	}

	@ApiImplicitParams({

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

	@RequestMapping(value = ProfitMandiConstants.URL_USER_SECONDRY_EMAIL_ID, method = RequestMethod.PUT)

	public ResponseEntity<?> updateSecondryEmailId(HttpServletRequest request,

		@RequestParam(name = ProfitMandiConstants.SECONDRY_EMAIL_ID) String secondryEmailId) throws Throwable {

	int userId = (int) request.getAttribute("userId");

	User user = userRepository.selectById(userId);

	user.setSecondryEmailId(secondryEmailId);

	userRepository.persist(user);

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

}

	@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)) {

			return responseSender.forbidden(null);

		}

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

		User user = null;

		try {

			user = userRepository.selectByEmailId(emailId);

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

		}

		if(user == null){

			try{

				user = userRepository.selectBySecondryEmailId(emailId);

			}catch(ProfitMandiBusinessException profitMandiBusinessException){

			}

		}

		if(user != null){

			int retailerId = 0;

			try {

				retailerId = userAccountRepository.selectRetailerIdByUserId(user.getId());

			} catch (ProfitMandiBusinessException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

			List<Integer> roleIds = userRoleRepository.selectRoleIdsByUserId(user.getId());

			String[] roleIdsString = new String[roleIds.size()];

			int index = 0;

			for (int roleId : roleIds) {

				roleIdsString[index++] = String.valueOf(roleId);

			}

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

			responseMap.put(ProfitMandiConstants.REGISTERED, true);

		}else{

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

			responseMap.put(ProfitMandiConstants.REGISTERED, false);

		}

		return responseSender.ok(responseMap);

	}

}