Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

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

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

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

import com.spice.profitmandi.dao.entity.auth.AuthUser;

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

import com.spice.profitmandi.dao.entity.cs.PartnerPosition;

import com.spice.profitmandi.dao.entity.cs.Position;

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.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.cs.PartnerPositionRepository;

import com.spice.profitmandi.dao.repository.cs.PositionRepository;

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

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

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

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

import com.spice.profitmandi.dao.repository.devtools.PasswordOverrideRepository;

import com.spice.profitmandi.service.AuthService;

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

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

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

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

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.Qualifier;

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

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

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

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

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

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

import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class AuthUserController {

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

	@Autowired

	private AuthService authService;

	@Autowired

	private UserService userService;

	@Autowired

	private PasswordOverrideRepository passwordOverrideRepository;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Value("${prod}")

	private boolean isProd;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	private RoleRepository roleRepository;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	private UserRoleRepository userRoleRepository;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	private PositionRepository positionRepository;

	@Autowired

	private PartnerPositionRepository partnerPositionRepository;

	@Autowired

	@Qualifier("userUserRepository")

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

	@GetMapping(value = "/createAuthUser")

	public String getcreateAuthUser(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

									@RequestParam(name = "limit", defaultValue = "0") int limit, Model model)

			throws ProfitMandiBusinessException {

		// List<AuthUser> authUsers = authRepository.selectAll(offset, limit);

		List<AuthUser> activeAuthUsers = authRepository.selectAllActiveUser();

		//List<AuthUser> authUsers = activeAuthUsers.stream().skip(offset).limit(limit).collect(Collectors.toList());

		List<AuthUser> authUsers = activeAuthUsers.stream().skip(offset).collect(Collectors.toList());

		Map<Integer, AuthUser> userManagerMap = activeAuthUsers.stream()

				.collect(Collectors.toMap(x -> x.getId(), x -> x));

		long size = activeAuthUsers.size();

		model.addAttribute("userManagerMap", userManagerMap);

		model.addAttribute("activeAuthUsers", activeAuthUsers);

		model.addAttribute("authUsers", authUsers);

		model.addAttribute("start", offset + 1);

		model.addAttribute("size", size);

		model.addAttribute("url", "/getPaginatedAuthUser");

		if (authUsers.size() < limit) {

			model.addAttribute("end", offset + authUsers.size());

		} else {

			model.addAttribute("end", offset + limit);

		}

		return "create-auth-user";

	}

	@PostMapping(value = "/addManagerId")

	public String addManagerId(HttpServletRequest request, @RequestParam(name = "authId") int authId,

			@RequestParam(name = "managerId") int managerId, Model model) throws Exception {

		// List<AuthUser> authUsers = authRepository.selectAll(offset, limit);

		AuthUser authUser = authRepository.selectById(authId);

		if (authUser.getId() != 0) {

			authUser.setManagerId(managerId);

		}

		List<AuthUser> activeAuthUsers = authRepository.selectAllActiveUser();

		AuthUser manager = authRepository.selectById(authUser.getManagerId());

		model.addAttribute("activeAuthUsers", activeAuthUsers);

		model.addAttribute("authUser", authUser);

		model.addAttribute("manager", manager);

		return "create-auth-user";

	}

	@PostMapping(value = "/createAuthUser")

	public String createAuthUser(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.FIRST_NAME, defaultValue = "") String firstName,

			@RequestParam(name = ProfitMandiConstants.LAST_NAME, defaultValue = "") String lastName,

			@RequestParam(name = ProfitMandiConstants.EMAIL_ID, defaultValue = "") String emailId,

			@RequestParam(name = ProfitMandiConstants.MOBILE_NUMBER, defaultValue = "") String mobileNumber,

			@RequestParam(name = ProfitMandiConstants.GMAIL_ID, defaultValue = "") String gmailId,

			@RequestParam(name = "employeeCode", defaultValue = "") String employeeCode,

								 @RequestParam(name = "imageUrl", defaultValue = "") String imageUrl,

								 @RequestParam(name = "offset", defaultValue = "0") int offset,

								 @RequestParam(name = "limit", defaultValue = "0") int limit, Model model)

			throws ProfitMandiBusinessException {

		AuthUser authUser = null;

		User user = null;

		List<Role> roles = roleRepository.selectAll();

		try {

			user = userRepository.selectByEmailId(emailId);

			userRoleRepository.deleteByUserId(user.getId());

			for (Role role : roles) {

				UserRole userRole = new UserRole();

				userRole.setRoleId(role.getId());

				userRole.setUserId(user.getId());

				userRoleRepository.persist(userRole);

			}

		} catch (Exception ex) {

			user = new User();

			user.setFirstName(firstName);

			user.setLastName(lastName);

			user.setUsername(emailId);

			user.setEmailId(emailId);

			user.setPassword("");

			user.setMobileNumber(mobileNumber);

			user.setCity("Noida");

			user.setPinCode(201301);

			user.setActivated(true);

			user.setMobile_verified(true);

			user.setReferral_url("");

			user.setUpdateTimestamp(LocalDateTime.now());

			user.setStatus(0);

			user.setCreateTimestamp(LocalDateTime.now());

			userRepository.persist(user);

			LOGGER.info("User created successfully");

			for (Role role : roles) {

				UserRole userRole = new UserRole();

				userRole.setRoleId(role.getId());

				userRole.setUserId(user.getId());

				userRoleRepository.persist(userRole);

			}

		}

		authUser = new AuthUser();

		authUser.setEmailId(emailId);

		authUser.setFirstName(firstName);

		authUser.setLastName(lastName);

		authUser.setMobileNumber(mobileNumber);

		authUser.setGmailId(gmailId);

		authUser.setImageUrl(imageUrl);

		authUser.setEmployeeCode(employeeCode);

		authUser.setActive(true);

		authUser.setCreatedTimestamp(LocalDateTime.now());

		authService.addAuthUser(authUser);

		List<AuthUser> authUsers = authRepository.selectAll(offset, limit);

		long size = authRepository.selectCountAuthUser();

		model.addAttribute("authUsers", authUsers);

		model.addAttribute("start", offset + 1);

		model.addAttribute("size", size);

		if (authUsers.size() < limit) {

			model.addAttribute("end", offset + authUsers.size());

		} else {

			model.addAttribute("end", offset + limit);

		}

		return "create-auth-user";

	}

	@GetMapping(value = "/changePassword")

	public String getChangePassword(HttpServletRequest request, Model model) {

		return "change-auth-user-password";

	}

	@PostMapping(value = "/changePassword")

	public String changePassword(HttpServletRequest request,

			@RequestParam(name = "oldPassword", defaultValue = "") String oldPassword,

			@RequestParam(name = "newPassword", defaultValue = "") String newPassword, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		authService.changePassword(loginDetails.getEmailId(), oldPassword, newPassword);

		return "change-auth-user-password";

	}

	@GetMapping(value = "/resetPasswordPage")

	public String getResetPasswordPage(HttpServletRequest request, Model model) {

		return "reset-password";

	}

	@PostMapping(value = "/resetPasswordOverride")

	public String resetPasswordOverride(HttpServletRequest request,

			@RequestParam(name = "type", defaultValue = "") String type,

			@RequestParam(name = "identifier", defaultValue = "") String identifier,

			@RequestParam(name = "retailerId", defaultValue = "0") int retailerId,

			@RequestParam(name = "partnerKey", defaultValue = "") String partnerKey,

			@RequestParam(name = "newPassword", defaultValue = "") String newPassword, Model model)

			throws Exception {

		if (isProd) {

			throw new ProfitMandiBusinessException("Access Denied", "Environment",

					"Password override is disabled in production");

		}

		// Partner may be given directly by store code or retailer id (partnerKey) instead of the autosuggest.

		if ("PARTNER".equalsIgnoreCase(type) && retailerId <= 0 && !partnerKey.trim().isEmpty()) {

			String key = partnerKey.trim();

			if (key.matches("\\d+")) {

				retailerId = Integer.parseInt(key);

			} else {

				retailerId = fofoStoreRepository.selectByStoreCode(key.toUpperCase()).getId();

			}

		}

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		applyOverride(type, retailerId, identifier, newPassword, loginDetails.getEmailId());

		model.addAttribute("response1", mvcResponseSender.createResponseString(true));

		return "response";

	}

	// Reset one target's live password and record it in devtools.password_override.

	private void applyOverride(String type, int retailerId, String identifier, String newPassword, String setBy)

			throws ProfitMandiBusinessException {

		if (newPassword == null || newPassword.trim().isEmpty()) {

			throw new ProfitMandiBusinessException("Password", "newPassword", "New password cannot be blank");

		}

		if ("PARTNER".equalsIgnoreCase(type)) {

			if (retailerId <= 0) {

				throw new ProfitMandiBusinessException("Partner", "retailerId", "Please select a partner");

			}

			String stored = userService.resetPasswordById(retailerId, newPassword);

			// Partner identifier is mandatorily the store code (resolved server-side, not from input).

			String storeCode = fofoStoreRepository.selectByRetailerId(retailerId).getCode();

			passwordOverrideRepository.upsert("PARTNER", 0, retailerId, storeCode, stored, newPassword, setBy);

			LOGGER.info("Password override for partner retailerId={} storeCode={} by {}", retailerId, storeCode, setBy);

		} else {

			if (identifier == null || identifier.trim().isEmpty()) {

				throw new ProfitMandiBusinessException("Auth User", "identifier", "Please enter an email or mobile");

			}

			authService.resetPassword(identifier.trim(), newPassword);

			AuthUser authUser = authRepository.selectByEmailOrMobile(identifier.trim());

			passwordOverrideRepository.upsert("AUTH_USER", authUser.getId(), 0, identifier.trim(),

					authUser.getPassword(), newPassword, setBy);

			LOGGER.info("Password override for authUser={} by {}", identifier.trim(), setBy);

		}

	}

	@GetMapping(value = "/passwordOverride/download")

	public ResponseEntity<?> downloadPasswordOverrides(HttpServletRequest request) throws Exception {

		if (isProd) {

			throw new ProfitMandiBusinessException("Access Denied", "Environment",

					"Password override is disabled in production");

		}

		java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();

		ExcelUtils.writePasswordOverrides(passwordOverrideRepository.selectAll(), out);

		byte[] bytes = out.toByteArray();

		HttpHeaders headers = new HttpHeaders();

		headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");

		headers.set("Content-disposition", "attachment; filename=password-overrides.xlsx");

		headers.setContentLength(bytes.length);

		return new ResponseEntity<>(new InputStreamResource(new java.io.ByteArrayInputStream(bytes)), headers,

				HttpStatus.OK);

	}

	@PostMapping(value = "/passwordOverride/upload")

	public String uploadPasswordOverrides(HttpServletRequest request,

			@RequestPart("file") MultipartFile file, Model model) throws Exception {

		if (isProd) {

			throw new ProfitMandiBusinessException("Access Denied", "Environment",

					"Password override is disabled in production");

		}

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		List<PasswordOverrideRow> rows = ExcelUtils.parsePasswordOverrides(file.getInputStream());

		int applied = 0;

		List<String> failures = new ArrayList<>();

		for (int i = 0; i < rows.size(); i++) {

			PasswordOverrideRow r = rows.get(i);

			if (r.getCleartextPassword() == null || r.getCleartextPassword().trim().isEmpty()) {

				continue; // blank password = leave this target unchanged

			}

			try {

				int retailerId = "PARTNER".equalsIgnoreCase(r.getType()) ? r.getRetailerId() : 0;

				applyOverride(r.getType(), retailerId, r.getIdentifier(), r.getCleartextPassword(),

						loginDetails.getEmailId());

				applied++;

			} catch (Exception e) {

				failures.add("Row " + (i + 2) + " (" + r.getType() + " "

						+ (r.getIdentifier() == null ? r.getRetailerId() : r.getIdentifier()) + "): " + e.getMessage());

			}

		}

		LOGGER.info("Bulk password override by {}: {} applied, {} failed", loginDetails.getEmailId(), applied,

				failures.size());

		model.addAttribute("response1", mvcResponseSender.createResponseString(

				"Applied " + applied + " of " + rows.size() + " row(s)."

						+ (failures.isEmpty() ? "" : " Failures: " + String.join("; ", failures))));

		return "response";

	}

	@GetMapping(value = "/getPaginatedAuthUser")

	public String getPaginatedAuthUser(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model) {

		// List<AuthUser> authUsers = authRepository.selectAll(offset, limit);

		List<AuthUser> activeAuthUsers = authRepository.selectAllActiveUser();

		List<AuthUser> authUsers = authRepository.selectAllActiveUser(offset, limit);

		Map<Integer, AuthUser> userManagerMap = new HashMap<>();

		for (AuthUser authUser : authUsers) {

			if (authUser.getManagerId() != 0) {

				userManagerMap.put(authUser.getId(), authRepository.selectById(authUser.getManagerId()));

			}

		}

		model.addAttribute("userManagerMap", userManagerMap);

		model.addAttribute("authUsers", authUsers);

		model.addAttribute("activeAuthUsers", activeAuthUsers);

		model.addAttribute("url", "/getPaginatedAuthUser");

		return "auth-users-paginated";

	}

	@GetMapping(value = "/authuser/edit")

	public String updateAuthUser(Model model, @RequestParam String gmailId, @RequestParam String emailId)

			throws Exception {

		AuthUser user = authRepository.selectByEmailOrMobile(emailId);

		user.setGmailId(gmailId);

		//authRepository.persist(user);

		model.addAttribute("response1", "true");

		return "response";

	}

	@GetMapping(value = "/authuser/editImageUrl")

	public String updateAuthUserImage(Model model, @RequestParam String imageUrl ,@RequestParam String emailId)

		throws Exception{

		AuthUser user = authRepository.selectByEmailOrMobile(emailId);

		user.setImageUrl(imageUrl);

		model.addAttribute("response1", "true");

		return "response";

	}

	@PostMapping(value = "/authuser/remove")

	public String removeAuthUser(Model model, @RequestParam int id) throws Exception {

		AuthUser user = authRepository.selectById(id);

		user.setActive(false);

		List<Position> positions = positionRepository.selectAllByAuthUserId(user.getId());

		for (Position position : positions) {

			List<PartnerPosition> partnerPositions = partnerPositionRepository.selectByPositionId(position.getId());

			positionRepository.delete(position.getId());

			for (PartnerPosition partnerPosition : partnerPositions) {

				partnerPositionRepository.delete(partnerPosition.getPositionId());

			}

		}

		model.addAttribute("response1", "true");

		return "response";

	}

}