Subversion Repositories SmartDukaan

package com.spice.profitmandi.common.util;

import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.List;

import javax.mail.internet.InternetAddress;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.spice.profitmandi.common.enumuration.DateTimePattern;

public class StringUtils {
        
        private static ObjectMapper objectMapper = new ObjectMapper();
        
        private static final Logger LOGGER = LoggerFactory.getLogger(StringUtils.class);
        private static final String DATE_PATTERN = "MM/dd/yyyy";
        private static final String DATE_PATTERN_HYPHENATED = "yyyy-MM-dd";
        private StringUtils(){

        }
        public static final LocalDate toDate(String dateString)throws DateTimeParseException{   
                LOGGER.info("Converting dateString [{}] with pattern[{}]", dateString, DATE_PATTERN);
                return LocalDate.parse(dateString);
        }

        public static final LocalDate fromHypendatedDate(String dateString)throws DateTimeParseException{       
                LOGGER.info("Converting dateString [{}] with pattern[{}]", dateString, DATE_PATTERN_HYPHENATED);
                return LocalDate.parse(dateString);
        }

        public static final LocalTime toTime(String timeString) throws DateTimeParseException{
                return LocalTime.parse(timeString);
        }
        
        public static final LocalDateTime toDateTime(long epocTime){
                return Instant.ofEpochMilli(epocTime).atZone(ZoneId.systemDefault()).toLocalDateTime();
        }
        
        public static final String toString(LocalDate localDate){
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern(DATE_PATTERN);
                String formattedDateTime = localDate.format(formatter);
                return formattedDateTime;
        }
        
        public static final LocalDateTime toDateTime(String dateTimeString) throws DateTimeParseException{
                if(dateTimeString == null || dateTimeString.equals("0") || dateTimeString.isEmpty()){
                        return null;
                }
                return LocalDateTime.parse(dateTimeString);
        }
        
        public static final LocalDateTime toDateTime(String dateTimeString, DateTimePattern dateTimePattern) throws DateTimeParseException{
                if(dateTimeString == null || dateTimeString.equals("0") || dateTimeString.isEmpty()){
                        return null;
                }
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern(dateTimePattern.getValue());
                return LocalDateTime.parse(dateTimeString, formatter);
        }

        public static boolean isValidMobile(String mobile){
                try{
                        Long.valueOf(mobile);
                }
                catch(Exception e){
                        return false;
                }

                if (mobile.startsWith("0")){
                        return false;
                }
                if (mobile.length()!=10){
                        return false;
                }
                return true;
        }

        public static boolean isValidEmailAddress(String email) {
                boolean result = true;
                try {
                        InternetAddress emailAddr = new InternetAddress(email);
                        emailAddr.validate();
                } catch (Exception ex) {
                        result = false;
                }
                return result;
        }
        
        public static List<String> getDuplicateElements(List<String> elements){
                List<String> duplicates = new ArrayList<>();
                for(int i = 0; i < elements.size(); i++){
                        for(int j = i + 1; j < elements.size(); j++){
                                if(elements.get(i).equals(elements.get(j))){
                                        duplicates.add(elements.get(i));
                                }
                        }
                }
                return duplicates;
        }
        
        public static String toString(Object object) throws Exception{
                try {
                        return objectMapper.writeValueAsString(object);
                } catch (JsonProcessingException e) {
                        LOGGER.error("Error occured while converting object to json", e);
                        throw e;
                }
        }
        public static boolean isValidPinCode(String pinCode){
                if(pinCode == null || pinCode.isEmpty()){
                        return false;
                }
                if(pinCode.length() != 6){
                        return false;
                }
                if(pinCode.startsWith("00") || pinCode.startsWith("01") || pinCode.startsWith("10")){
                        return false;
                }
                return true;
                
        }
        
        public static String generatePolicyNumber(String prefix, int sequence){
                String policyNumber = String.format(prefix + "%06d", sequence);
                LOGGER.info("Generated Policy Number {}", policyNumber);
                return policyNumber;
        }
        
        public static String generateFofoStoreSequence(String prefix, int sequence){
                String fofoStoreSequenceNumber = String.format(prefix + "%03d", sequence);
                LOGGER.info("Generated Fofo Store Sequence Number {}", fofoStoreSequenceNumber);
                return fofoStoreSequenceNumber;
        }

}