Subversion Repositories SmartDukaan

package com.spice.profitmandi.service;

import com.google.common.hash.Hashing;

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

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

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

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

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

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

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

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

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

import org.apache.commons.lang.RandomStringUtils;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.stereotype.Component;

import java.nio.charset.StandardCharsets;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.stream.Collectors;

@Component

public class AuthServiceImpl implements AuthService {

    // private static final String RESET_PASSWORD_BODY = "Dear %s, your password has

    // been reset. Please click this <a href=\"%s\">link</a> to reset your

    // password.\n\nRegards\nSmartdukaan";

    private static final String RESET_PASSWORD_BODY = "Dear %s, \nyour password has been reset to %s. \n\nRegards\nSmartdukaan";

    private static final String RESET_PASSWORD_SUBJECT = "Password Reset request";

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

    @Autowired

    AuthRepository authRepository;

    @Autowired

    JavaMailSender mailSender;

    @Autowired

    PromoterRepository promoterRepository;

    @Autowired

    UserRepository userRepository;

    @Autowired

    UserService userService;

    private String getHash256(String originalString) {

        return Hashing.sha256().hashString(originalString, StandardCharsets.UTF_8).toString();

    }

    @Override

    public List<Integer> getDirectReportees(int authId) {

        List<AuthUser> authUsers = authRepository.selectAllByManagerAuthId(authId);

        List<Integer> authIds = authUsers.stream().map(x -> x.getId()).collect(Collectors.toList());

        LOGGER.info("Auth Id == {}, All Reportees === {}", authId, authIds);

        return authIds;

    }

    @Override

    public List<AuthUser> getAllManagers(int authId) {

        AuthUser authUser = authRepository.selectById(authId);

        List<AuthUser> managersHierarchy = new ArrayList<>();

        // To prevent infinite loops due to circular references

        Set<Integer> visitedIds = new HashSet<>();

        visitedIds.add(authId);

        while (authUser != null && authUser.getManagerId() != 0) {

            int managerId = authUser.getManagerId();

            if (visitedIds.contains(managerId)) {

                LOGGER.warn("Circular reference detected: authId {} -> managerId {}", authUser.getId(), managerId);

                break;

            }

            AuthUser manager = authRepository.selectById(managerId);

            if (manager == null) {

                LOGGER.warn("Manager with ID {} not found for user {}", managerId, authUser.getId());

                break;

            }

            managersHierarchy.add(manager);

            visitedIds.add(managerId);

            authUser = manager;

        }

        LOGGER.info("managersHierarchy {}", managersHierarchy);

        return managersHierarchy;

    }

    public List<Integer> getAllReportees(int authId) {

        return getAllReportees(authId, new HashSet<>());  // call helper with visited set

    }

    private List<Integer> getAllReportees(int authId, Set<Integer> visited) {

        List<Integer> allReportees = new ArrayList<>();

        List<Integer> directReporteeIds = this.getDirectReportees(authId);

        for (int directReporteeId : directReporteeIds) {

            if (!visited.contains(directReporteeId)) {

                visited.add(directReporteeId); // mark visited

                allReportees.add(directReporteeId);

                // recursively get sub-reportees

                allReportees.addAll(getAllReportees(directReporteeId, visited));

            }

        }

        return allReportees;

    }

    @Override

    public boolean authenticate(String emailOrMobile, String password) {

        return authRepository.authenticate(emailOrMobile, getHash256(password));

    }

    @Override

    public void resetPassword(String emailOrMobile) throws ProfitMandiBusinessException {

        AuthUser authUser = authRepository.selectByEmailOrMobile(emailOrMobile);

        String password = getRandomString();

        try {

            Utils.sendMailWithAttachments(mailSender, authUser.getEmailId(), null, RESET_PASSWORD_SUBJECT,

                    String.format(RESET_PASSWORD_BODY, authUser.getFirstName(), password), null);

        } catch (Exception e) {

            throw new ProfitMandiBusinessException("Password Reset Email", emailOrMobile,

                    "Could not send password reset mail. Password Could not be reset");

        }

        userService.resetPassword(emailOrMobile, password);

        authUser.setPassword(getHash256(password));

    }

    @Override

    public void resetPassword(String emailOrMobile, String password) throws ProfitMandiBusinessException {

        try {

            AuthUser authUser = authRepository.selectByEmailOrMobile(emailOrMobile);

            authUser.setPassword(getHash256(password));

            userService.resetPassword(emailOrMobile, password);

        } catch (ProfitMandiBusinessException e) {

            userService.resetPassword(emailOrMobile, password);

        }

    }

    @Override

    public void changePassword(String emailOrMobile, String oldPassword, String newPassword) throws ProfitMandiBusinessException {

        if (authRepository.authenticate(emailOrMobile, getHash256(oldPassword))) {

            AuthUser authUser = authRepository.selectByEmailOrMobile(emailOrMobile);

            authUser.setPassword(getHash256(newPassword));

            userService.resetPassword(authUser.getEmailId(), newPassword);

        } else {

            throw new ProfitMandiBusinessException("Authentication", "Credentials", "Invalid email/mobile or password");

        }

    }

    @Override

    public void addAuthUser(AuthUser authUser) throws ProfitMandiBusinessException {

        try {

            authRepository.selectByEmailOrMobile(authUser.getEmailId());

        } catch (ProfitMandiBusinessException pbse) {

            try {

                authRepository.selectByEmailOrMobile(authUser.getMobileNumber());

            } catch (ProfitMandiBusinessException e) {

                authRepository.persist(authUser);

                this.resetPassword(authUser.getEmailId());

                return;

            }

            throw new ProfitMandiBusinessException("Mobile", authUser.getMobileNumber(), "Mobile number already exist");

        }

        throw new ProfitMandiBusinessException("Email", authUser.getEmailId(), "Email Id already exist");

    }

    private String getRandomString() {

        int length = 10;

        boolean useLetters = true;

        boolean useNumbers = false;

        String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);

        return generatedString;

    }

    @Override

    public String getNameByEmailId(String email) {

        AuthUser authUser = authRepository.selectByGmailId(email);

        String userName = null;

        if (authUser != null) {

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

        } else {

            if (promoterRepository.selectMappedByEmailId(email) != null) {

                Promoter promoter = promoterRepository.selectMappedByEmailId(email);

                userName = promoter.getName();

            } else if (userRepository.isExistBySecondryEmailId(email)) {

                try {

                    User user = userRepository.selectBySecondryEmailId(email);

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

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        }

        LOGGER.info("User Name from getNameByEmailId({}) is {}", email, userName);

        return userName;

    }

}