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.dao.entity.auth.AuthUser;
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.UserRepository;
import com.spice.profitmandi.dao.repository.dtr.UserRoleRepository;
import com.spice.profitmandi.service.AuthService;
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.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 javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
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 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 = "/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";
        }

}