Subversion Repositories SmartDukaan

package com.smartdukaan.cron.scheduled;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import com.smartdukaan.cron.migrations.RunOnceTasks;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.dao.entity.fofo.ActivatedImei;
import com.spice.profitmandi.dao.model.VivoImeiAndActivationTimeStampModel;
import com.spice.profitmandi.dao.repository.fofo.ActivatedImeiRepository;
import com.spice.profitmandi.service.inventory.InventoryService;

import okhttp3.Cookie;
import okhttp3.CookieJar;
import okhttp3.FormBody;
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

@Component
class VivoImeiActivationService {

        @Autowired
        InventoryService inventoryService;

        @Autowired
        CaptchaService captchaService;
        
        @Autowired
        ActivatedImeiRepository activatedImeiRepository;

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

        private final Map<String, List<Cookie>> cookieStore = new HashMap<>();

        public void checkImeiActivation() throws ProfitMandiBusinessException, IOException, Exception {
                
                OkHttpClient okHttpClient = new OkHttpClient.Builder().cookieJar(new CookieJar() {
                        @Override
                        public void saveFromResponse(HttpUrl httpUrl, List<Cookie> list) {
                                LOGGER.info("SAVE fROM - {}", httpUrl.host());
                                cookieStore.put(httpUrl.host(), list);
                        }

                        @Override
                        public List<Cookie> loadForRequest(HttpUrl httpUrl) {
                                List<Cookie> cookies = cookieStore.get(httpUrl.host());
                                LOGGER.info("load from - {}", httpUrl.host());
                                return cookies != null ? cookies : new ArrayList<Cookie>();
                        }
                }).build();
                
                String captchaBreak = this.getNewCaptcha(okHttpClient);

                Object status = null;
                LOGGER.info("Captcha code {}", captchaBreak);
                
                 List<VivoImeiAndActivationTimeStampModel>   imeisActivationList =activatedImeiRepository.selectVivoImeiAndActivationTimeStamp();
                 
                 LOGGER.info("imeisActivationList {}", imeisActivationList);
                        int count= 0;
                        
                        Map<String, LocalDateTime> imeisActivationMap = new HashMap<>();
                        
                        for(VivoImeiAndActivationTimeStampModel imeisActivation :imeisActivationList) 
                        {
                                count++;
                                imeisActivationMap.put(imeisActivation.getSerialNumber(), imeisActivation.getActivationTimestamp());
                                
                                if(count == 5000  )
                                {
                                 status = this.getImeiActivation(captchaBreak, okHttpClient,imeisActivationMap);
                                        
                                 
                                 if (status.equals(0)) {
                                                this.generate(captchaBreak, okHttpClient,imeisActivationMap);
                                                }
                                        count= 5005;
                                        
                                }
                                
                                if(count==5005)
                                {
                                        break;
                                        
                                }
                        }

        }

        // assign uppercase of ch1, ch2 to ch3, ch4

        

        // Get Captcha file

        // Call Api to break captcha
        // Iterate and fetch activation information using captcha code.

        // inventoryService.addActivatedImeis(imeisActivationMap );

        public void generate(String input, OkHttpClient okHttpClient,Map<String, LocalDateTime> imeisActivationMap) {
                int n = input.length();
                int max = 1 << n;
                input = input.toLowerCase();
                int statusCount = 0;
                
                Object statusUpper = null;
                char combination[] = null;
                for (int i = 0; i < max; i++) {
                        combination = input.toCharArray();
                        for (int j = 0; j < n; j++) {
                                if (((i >> j) & 1) == 1)
                                        combination[j] = (char) (combination[j] - 32);
                        }
                        LOGGER.info("combination" + String.valueOf(combination));       
                        try {
                                statusUpper = this.getImeiActivation(String.valueOf(combination), okHttpClient,imeisActivationMap);
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        
                        if (!statusUpper.equals(0)) {
                                statusCount = 1;
                                break;
                        }

                }
                
                
                if(statusCount == 0 )
                {
                        
                        try {
                        String freshCaptcha =   this.getNewCaptcha(okHttpClient);
                        
                        this.generate(freshCaptcha, okHttpClient, imeisActivationMap);          
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
                
                LOGGER.info("statusUpper" + statusUpper);
        }

        
        public String getNewCaptcha(OkHttpClient okHttpClient) throws Exception 
        
        {
                
                
                LOGGER.info("okHttpClient" + okHttpClient);

                HttpUrl vivoSupportUrl = HttpUrl.parse("https://www.vivo.com/in/support/generatingCodes");
                Request request = new Request.Builder().url(vivoSupportUrl).build();

                Response response = okHttpClient.newCall(request).execute();
                LOGGER.info("cookie {}", this.cookieStore.values());
                
                LOGGER.info("vivoSupportUrl" + vivoSupportUrl);
                LOGGER.info("request" + request);
                LOGGER.info("request" + request);

                String filePath = "/tmp/captcha.avif";
                Files.write(Paths.get(filePath), response.body().bytes());

                // Get all relevent imes from activatedImei and inventoryItem for vivo


                String captchaBreak = captchaService.getCaptchaCode(filePath);
                
                
                return captchaBreak;
        }
        
        
        public Object getImeiActivation(String captchaBreak, OkHttpClient okHttpClient ,Map<String, LocalDateTime> imeisActivationMap ) throws IOException {

                
                Object status = 0;

                for (Map.Entry<String,LocalDateTime> imei :  imeisActivationMap.entrySet()) {
                        
                        LOGGER.info("imei" + imei);
                        RequestBody formBody = new FormBody.Builder()
                                        .add("imei", imei.getKey())
                                        .add("code", captchaBreak)
                                        .build();

                        Request request1 = new Request.Builder().url("https://www.vivo.com/in/support/checkCode").post(formBody)
                                        .build();

                        Response response2 = okHttpClient.newCall(request1).execute();
                        JSONObject imeiActivationJson = new JSONObject(response2.body().string());
                        LOGGER.info("imeiActivationJson" + imeiActivationJson);
                        JSONObject data = imeiActivationJson.getJSONObject("data");
                        
                        JSONObject imeiQueryDto =data.getJSONObject("imeiQueryDto");
                        
                        Object dueTimeObject = imeiQueryDto.get("dueTime");
                        String dueTimeString =  dueTimeObject.toString();
                        
                        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
                String dueTimeSplit = dueTimeString.split(" ")[0];
                
                status = data.get("status");
                
                if(!StringUtils.isEmpty(dueTimeSplit))
                {
      
                        LocalDate dateTime = LocalDate.parse(dueTimeSplit, formatter);
        
                        LOGGER.info("data" + data);
                        
                        LOGGER.info("status" + status);
                        
                        
                        ActivatedImei activatedImei=    activatedImeiRepository.selectBySerialNumber(imei.getKey());
                        
                        if(activatedImei == null)
                                
                        {
                                activatedImei    = new  ActivatedImei();
                                activatedImei.setActivationTimestamp(dateTime.atStartOfDay().minusYears(1));
                                activatedImei.setSerialNumber(imei.getKey());
                                activatedImei.setCreateTimestamp(LocalDateTime.now());
                                 activatedImeiRepository.persist(activatedImei);
                        
                        }
                        else {
                                activatedImei.setActivationTimestamp(dateTime.atStartOfDay().minusYears(1));
                                
                        }
                        
                        LOGGER.info("activatedImei" + activatedImei);
                        
                        LOGGER.info("vivoImeiStatusModel" + dateTime.atStartOfDay());
                        
                        
                }
                        
                   
                        
                        if (status.equals(0)) {

                                return status;
                        }
                }

                return status;
        }
}