Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.util;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Type;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.io.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.spice.profitmandi.common.enumuration.ContentType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.util.FileUtil;
import com.spice.profitmandi.common.util.Utils;
import com.spice.profitmandi.dao.entity.dtr.Document;
import com.spice.profitmandi.dao.entity.dtr.Retailer;
import com.spice.profitmandi.dao.entity.dtr.RetailerRegisteredAddress;
import com.spice.profitmandi.dao.entity.dtr.User;
import com.spice.profitmandi.dao.entity.dtr.UserAccounts;
import com.spice.profitmandi.dao.entity.dtr.UserRole;
import com.spice.profitmandi.dao.entity.user.Address;
import com.spice.profitmandi.dao.enumuration.dtr.AccountType;
import com.spice.profitmandi.dao.enumuration.dtr.RetailerType;
import com.spice.profitmandi.dao.enumuration.dtr.RoleType;
import com.spice.profitmandi.dao.repository.dtr.DocumentRepository;
import com.spice.profitmandi.dao.repository.dtr.Mongo;
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
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;

@Component
public class MigrationUtil {
        
        @Autowired
        DocumentRepository documentRepository;
        
        @Autowired
        UserRepository userRepository;
        
        @Autowired
        UserAccountRepository userAccountRepository;
        
        @Autowired
        RetailerRepository retailerRepository;
        
        @Autowired
        UserRoleRepository userRoleRepository;
        
        @Autowired
        AddressRepository addressRepository;
        
        @Autowired
        RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
        

        @Autowired
        Mongo mongoClient;
        
        
        private static final Logger LOGGER = LoggerFactory.getLogger(MigrationUtil.class);
        
        private List<Map<String, String>> getMongoFofoDoc(){
                String fofoFormsJsonString = mongoClient.getFofoFormsJsonString();
                
                Gson gson = new Gson();
        Type paths = new TypeToken<List<Map<String, String>>>(){}.getType();
        List<Map<String, String>> maps = gson.fromJson(fofoFormsJsonString, paths);
        return maps;
        }
        
        public void migrateMongoDocToDocumentId() throws ProfitMandiBusinessException{
                List<Map<String, String>> maps = this.getMongoFofoDoc();
        Map<Integer, Map<String, Integer>> fofoIdPathMap = new HashMap<>();
        
        for(Map<String, String> map : maps){
                int id = 0;
                Map<String, Integer> pathMap = new HashMap<>();
                for(Map.Entry<String, String> entry : map.entrySet()){
                        if(entry.getKey().equals("_id")){
                                id = (int)Double.parseDouble(entry.getValue());
                        }
                        if(entry.getValue().startsWith("/hsps-docs/")){
                                
                                Document document = new Document();
                                
                                try{
                                        File srcFile = new File(entry.getValue());
                                        String destFileName = entry.getValue().substring(entry.getValue().lastIndexOf('/') + 1);
                                        String destFilePath = "/uploads/"; 
                                        File destFile = new File(destFilePath + destFileName);
                                        FileUtils.copyFile(srcFile, destFile);
                                        ContentType contentType = FileUtil.detectFileType(srcFile);
                                        document.setContentType(contentType);
                                        document.setName(destFileName);
                                        document.setPath(destFilePath);
                                        document.setPersisted(true);
                                        document.setSize(srcFile.length());
                                        documentRepository.persist(document);
                                        pathMap.put(entry.getKey(), document.getId());
                                }catch(IOException ioException) {
                                        LOGGER.info("IOException occurred");
                                }
                        }
                }
                if(!pathMap.isEmpty()){
                        fofoIdPathMap.put(id, pathMap);
                }
        }
        
        LOGGER.info("fofoIdPathMap {}", fofoIdPathMap);
        for(Map.Entry<Integer, Map<String, Integer>> entry : fofoIdPathMap.entrySet()){
                mongoClient.updateColumnsById(entry.getValue(), entry.getKey());
        }
        
        }
        
        public void migrateUserToRetailer(){
                Set<Integer> ids = new HashSet<>();
                List<Integer> userIds = userRepository.selectIdAll();
                List<UserAccounts> saholicUserAccounts = userAccountRepository.selectAllSaholicByUserIds(new HashSet<>(userIds));
                for(UserAccounts saholicUserAccount : saholicUserAccounts){
                        Retailer retailer = new Retailer();
                        int retailerId = Integer.parseInt(saholicUserAccount.getAccount_key());
                        retailer.setId(retailerId);
                        retailer.setMigrated(true);
                        if(!ids.add(retailerId)){
                                LOGGER.info("Duplicate retailerId {}", retailerId);
                        }
                        try {
                                retailerRepository.persist(retailer);
                        } catch (ProfitMandiBusinessException e) {
                                LOGGER.info("Error occured while commiting retailer");
                                e.printStackTrace();
                        }
                        UserRole userRole1 = new UserRole();
                        userRole1.setRoleType(RoleType.RETAILER);
                        userRole1.setUserId(saholicUserAccount.getUser_id());
                        try {
                                userRoleRepository.persist(userRole1);
                        } catch (ProfitMandiBusinessException e) {
                                e.printStackTrace();
                        }
                        
                        UserRole userRole2 = new UserRole();
                        userRole2.setRoleType(RoleType.USER);
                        userRole2.setUserId(saholicUserAccount.getUser_id());
                        try {
                                userRoleRepository.persist(userRole2);
                        } catch (ProfitMandiBusinessException e) {
                                e.printStackTrace();
                        }
                }
        }
        
        public void migrateMongoDocToRetailer() throws ProfitMandiBusinessException{
                List<Map<String, String>> maps = this.getMongoFofoDoc();
                Set<String> emailIds = new HashSet<>();
                for(Map<String, String> map : maps){
                        if(map.containsKey("registeredEmail1")){
                                emailIds.add(map.get("registeredEmail1"));
                        }
                }
                List<String> foundEmailIds = userRepository.selectEmailIdsByEmailIds(emailIds);
                emailIds.removeAll(foundEmailIds);
                for(Map<String, String> map : maps){
                        if(map.containsKey("registeredEmail1") && emailIds.contains(map.get("registeredEmail1"))){
                                User user = new User();
                                user.setFirstName("");
                                user.setLastName("");
                                user.setCity(map.containsKey("city") ? map.get("city") : "");
                                user.setPinCode(Integer.valueOf(map.containsKey("pincode") ? map.get("pincode") : ""));
                                user.setMobileNumber(map.containsKey("mobile") ? map.get("mobile") : "");
                                user.setEmailId(map.get("registeredEmail1"));
                                user.setUsername(map.get("registeredEmail1"));
                                user.setPassword("");
                                user.setMobile_verified(false);
                                user.setReferral_url("");
                                user.setGroup_id(1);
                                user.setStatus(0);
                                user.setActivated(false);
                                user.setCreateTimestamp(LocalDateTime.now());
                                user.setUpdateTimestamp(LocalDateTime.now());
                                userRepository.persist(user);
                                
                                in.shop2020.model.v1.user.User saholicUser = Utils.createSaholicUser(map.get("registeredEmail1"));
                                
                                Retailer retailer = new Retailer();
                                retailer.setActive(true);
                                retailer.setFofo(true);
                                retailer.setId(Long.valueOf(saholicUser.getUserId()).intValue());
                                retailer.setMigrated(true);
                                retailer.setName(map.containsKey("registeredBusinessName") ? map.get("registeredBusinessName") : "");
                                retailer.setType(RetailerType.GSTIN);
                                retailerRepository.persist(retailer);
                                
                                Address retailerAddress = new Address();
                                retailerAddress.setCity(map.containsKey("city") ? map.get("city") : "");
                                retailerAddress.setCountry("India");
                                retailerAddress.setEnabled(true);
                                retailerAddress.setLandmark("");
                                retailerAddress.setLine1(map.containsKey("line1") ? map.get("line1") : "");
                                retailerAddress.setLine2(map.containsKey("line2") ? map.get("line2") : "");
                                retailerAddress.setName(map.containsKey("registeredBusinessName") ? map.get("registeredBusinessName") : "");
                                retailerAddress.setPhoneNumber(map.containsKey("mobile") ? map.get("mobile") : "");
                                retailerAddress.setPinCode(map.containsKey("pincode") ? map.get("pincode") : "");
                                retailerAddress.setState(map.containsKey("state") ? map.get("state") : "");
                                addressRepository.persist(retailerAddress);
                                
                                RetailerRegisteredAddress retailerRegisteredAddress = new RetailerRegisteredAddress();
                                retailerRegisteredAddress.setAddressId(retailerAddress.getId());
                                retailerRegisteredAddress.setRetailerId(retailer.getId());
                                retailerRegisteredAddressRepository.persist(retailerRegisteredAddress);
                                
                                UserAccounts saholicUserAccounts = new UserAccounts();
                                saholicUserAccounts.setAccount_key(String.valueOf(saholicUser.getUserId()));
                                saholicUserAccounts.setAccount_type(AccountType.saholic);
                                saholicUserAccounts.setUser_id(user.getId());
                                userAccountRepository.persist(saholicUserAccounts);
                                UserAccounts cartUserAccounts = new UserAccounts();
                                cartUserAccounts.setAccount_key(String.valueOf(saholicUser.getActiveCartId()));
                                cartUserAccounts.setAccount_type(AccountType.cartId);
                                cartUserAccounts.setUser_id(user.getId());
                                userAccountRepository.persist(cartUserAccounts);
                                
                        }
                }
        }
        
        public void migratePrivateDealToRetailer(){
                
        }
}