Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.config;

import com.fasterxml.jackson.core.JsonParser;

import com.fasterxml.jackson.databind.*;

import com.fasterxml.jackson.databind.deser.ContextualDeserializer;

import com.fasterxml.jackson.databind.deser.std.StringDeserializer;

import com.fasterxml.jackson.databind.module.SimpleModule;

import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;

import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;

import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;

import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;

import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;

import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;

import com.google.gson.Gson;

import com.google.gson.GsonBuilder;

import com.spice.profitmandi.common.services.AuthenticatedIdentityMailSender;

import com.spice.profitmandi.common.services.MailRecipientFilter;

import com.spice.profitmandi.common.services.RecipientFilteringMailSender;

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

import com.spice.profitmandi.dao.convertor.LocalDateTimeJsonConverter;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.apache.velocity.app.VelocityEngine;

import org.apache.velocity.exception.VelocityException;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Lazy;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Primary;

import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

import org.springframework.context.support.ReloadableResourceBundleMessageSource;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.mail.javamail.JavaMailSenderImpl;

import org.springframework.ui.velocity.VelocityEngineFactoryBean;

import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import org.springframework.web.servlet.ViewResolver;

import org.springframework.web.servlet.view.BeanNameViewResolver;

import org.springframework.web.servlet.view.velocity.VelocityConfigurer;

import org.springframework.web.servlet.view.velocity.VelocityLayoutViewResolver;

import java.io.IOException;

import java.math.RoundingMode;

import java.text.DecimalFormat;

import java.text.NumberFormat;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.time.format.DateTimeFormatterBuilder;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import java.util.Properties;

@SuppressWarnings("deprecation")

@Configuration

@ComponentScan("com.spice.profitmandi.*")

//@Import(RepositoryRestMvcConfiguration.class)

public class AppConfig {

    private static final String VELOCITY_PATH_PREFIX = "/WEB-INF/views/ftl/";

    private static final String VELOCITY_PATH_SUFFIX = ".vm";

    private static final String MESSAGE_PATH_SOURCE_NAME = "classpath:messages";

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

    private static Resource resource;

    private static Resource sharedResource;

    public static Resource getResource() {

        return resource;

    }

    public static Resource getSharedResource() {

        return sharedResource;

    }

    public void setResource(Resource resource) {

        AppConfig.resource = resource;

    }

    @Bean(value = "velocityAttributesMap")

    public Map<String, Object> velocityAttributesMap() {

        Map<String, Object> attributesMap = new HashMap<>();

        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");

        DateTimeFormatter dateMonthFormatter = DateTimeFormatter.ofPattern("dd''MMM");

        DateTimeFormatter datehiphenFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        DateTimeFormatter dateMonthYearFormatter = DateTimeFormatter.ofPattern("MM-yyyy");

        DateTimeFormatter dateYearMonthFormatter = DateTimeFormatter.ofPattern("MMM''uu");

        DateTimeFormatter dateMonthChYear = DateTimeFormatter.ofPattern("d''MMM''uu");

        DecimalFormat decimalFormatter = new DecimalFormat("0.#");

        NumberFormat numberformat = NumberFormat.getNumberInstance(new Locale("en", "IN"));

        numberformat.setRoundingMode(RoundingMode.HALF_DOWN);

        numberformat.setMaximumFractionDigits(2);

        numberformat.setMinimumFractionDigits(0);

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");

        attributesMap.put("dateFormatter", dateFormatter);

        attributesMap.put("nf", numberformat);

        attributesMap.put("dateMonthFormatter", dateMonthFormatter);

        attributesMap.put("datehiphenFormatter", datehiphenFormatter);

        attributesMap.put("dateYearMonthFormatter", dateYearMonthFormatter);

        attributesMap.put("dateMonthYearFormatter", dateMonthYearFormatter);

        attributesMap.put("dateMonthChYear", dateMonthChYear);

        attributesMap.put("decimalFormatter", decimalFormatter);

        attributesMap.put("noData", "<tr><td colspan=\"20\" style=\"text-align:center;\">No results found for the given criteria</td></tr>");

        attributesMap.put("dateTimeFormatter", dateTimeFormatter);

        attributesMap.put("version", "433");

        attributesMap.put("cssVersion", "53");

        attributesMap.put("isDev", getActiveProfile().equals("dev"));

        attributesMap.put("vmUtils", new Utils());

        //attributesMap.put("esc", new EscapeTool());

        attributesMap.put("ru", RoundingMode.HALF_UP);

        return attributesMap;

    }

    @Bean

    public ViewResolver viewResolver() {

        VelocityLayoutViewResolver bean = new VelocityLayoutViewResolver();

        bean.setPrefix("");

        bean.setSuffix(VELOCITY_PATH_SUFFIX);

        bean.setContentType("text/html;charset=UTF-8");

        bean.setRequestContextAttribute("rc");

        bean.setExposeSpringMacroHelpers(true);

        bean.setAttributesMap(this.velocityAttributesMap());

        return bean;

    }

    @Bean

    public ViewResolver beanNameViewResolver() {

        BeanNameViewResolver resolver = new BeanNameViewResolver();

        return resolver;

    }

    @Bean

    public VelocityConfigurer velocityConfig() {

        VelocityConfigurer velocityConfigurer = new VelocityConfigurer();

        Properties velocityProperties = new Properties();

       /* velocityProperties.put("velocimacro.library", "macros.vm");

        velocityProperties.put("velocimacro.permissions.allow.inline", "true");

        velocityProperties.put("velocimacro.permissions.allow.inline.to.replace.global", "true");*/

        velocityProperties.put("directive.set.null.allowed", "true");

        // Read .vm files as UTF-8 and emit UTF-8 — otherwise non-ASCII chars

        // (emoji, accents) in templates render as mojibake (e.g. 📷 → ð).

        velocityProperties.put("input.encoding", "UTF-8");

        velocityProperties.put("output.encoding", "UTF-8");

        velocityConfigurer.setVelocityProperties(velocityProperties);

        velocityConfigurer.setResourceLoaderPath(VELOCITY_PATH_PREFIX);

        return velocityConfigurer;

    }

    @Bean(name = "messageSource")

    public ReloadableResourceBundleMessageSource getReloadableResourceBundleMessageSource() {

        LOGGER.debug("creating messageSource bean with message path source name : " + MESSAGE_PATH_SOURCE_NAME);

        ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();

        messageSource.setBasename(MESSAGE_PATH_SOURCE_NAME);

        messageSource.setDefaultEncoding("UTF-8");

        return messageSource;

    }

    @Bean(name = "multipartResolver")

    public CommonsMultipartResolver getCommonsMultipartResolver() {

        LOGGER.info("creating common multipart resolver bean");

        return new CommonsMultipartResolver();

    }

    @Bean

    public PropertySourcesPlaceholderConfigurer propertyConfigurer1() {

        String activeProfile = getActiveProfile();

        PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new PropertySourcesPlaceholderConfigurer();

        Resource appResource;

        Resource sharedResource;

        if ("prod".equals(activeProfile)) {

            appResource = new ClassPathResource("/META-INF/prod.properties");

            sharedResource = new ClassPathResource("/shared-prod.properties");

        } else if ("staging".equals(activeProfile)) {

            appResource = new ClassPathResource("/META-INF/staging.properties");

            sharedResource = new ClassPathResource("/shared-staging.properties");

        } else {

            appResource = new ClassPathResource("/META-INF/dev.properties");

            sharedResource = new ClassPathResource("/shared-dev.properties");

        }

        resource = appResource;

        AppConfig.sharedResource = sharedResource;

        // Load shared properties from dao first, then app-specific (app-specific can override)

        propertySourcesPlaceholderConfigurer.setLocations(sharedResource, appResource);

        propertySourcesPlaceholderConfigurer.setIgnoreResourceNotFound(true);

        return propertySourcesPlaceholderConfigurer;

    }

    private String getActiveProfile() {

        Properties properties = new Properties();

        try {

            properties.load(this.getClass().getClassLoader().getResourceAsStream("META-INF/env.property"));

        } catch (IOException e) {

            LOGGER.error("Error in reading env property file.Adding default property" + e);

            properties.put("profile", "dev");

        }

        LOGGER.info("Profile is [{}]", properties.get("profile"));

        return (String) properties.get("profile");

    }

    /**

     * The default sender.

     *

     * Verified working 2026-08-31: MAIL FROM:<noreply@smartdukaan.com> returns 250

     * over IPv4. It does not authenticate -- Workspace authorises it by allowlisted

     * source IP -- so it may legitimately send as noreply@.

     *

     * googleMailSender is the alternative and its credentials are valid -- verified

     * 2026-08-31, AUTH OK on both 465 and 587. Use it by qualifier where a message

     * must come from the authenticated identity rather than noreply@.

     *

     * SMTP on this host works over IPv4 only, and that is not specific to the relay:

     * over IPv6 the relay answers "550 5.7.1 Invalid credentials for relay" and

     * smtp.gmail.com rejects a valid app password with "535 5.7.8 Username and

     * Password not accepted". The JVM prefers IPv4, which is the only reason mail

     * leaves this box at all. Anything that prefers IPv6 will fail on both paths.

     */

    @Bean(name = {"gmailRelaySender", "mailSender"})

    @Primary

    public JavaMailSender getGmailRelaySender(@Lazy MailRecipientFilter mailRecipientFilter) {

        RecipientFilteringMailSender mailSender = new RecipientFilteringMailSender();

        mailSender.setRecipientFilter(mailRecipientFilter);

        mailSender.setHost("smtp-relay.gmail.com");

        mailSender.setPort(587);

        Properties props = mailSender.getJavaMailProperties();

        props.put("mail.smtp.starttls.enable", "true");

        props.put("mail.smtp.auth", "false");

        props.put("mail.smtp.localhost", "smartdukaan.com");

        props.put("mail.smtp.ssl.protocols", "TLSv1.2");

        props.put("mail.smtp.ssl.trust", "smtp-relay.gmail.com");

        props.put("mail.transport.protocol", "smtp");

        props.put("mail.smtp.connectiontimeout", "30000");

        props.put("mail.smtp.timeout", "120000");

        props.put("mail.smtp.writetimeout", "120000");

        return mailSender;

    }

    /**

     * The default sender. Authenticates as sdtech@smartdukaan.com and rewrites every

     * From to that identity — Workspace binds an authenticated session to one address

     * and rejects any other. Also answers to "mailSender" so unqualified

     * JavaMailSender injections resolve here.

     */

    @Bean(name = "googleMailSender")

    public JavaMailSender googleMailSender(@Lazy MailRecipientFilter mailRecipientFilter) {

        AuthenticatedIdentityMailSender mailSender = new AuthenticatedIdentityMailSender();

        mailSender.setRecipientFilter(mailRecipientFilter);

        mailSender.setHost("smtp.gmail.com");

        mailSender.setPort(465);

        mailSender.setUsername("sdtech@smartdukaan.com");

        mailSender.setPassword("wbdwyqrcgosrkwdn"); // App Password

        Properties props = mailSender.getJavaMailProperties();

        props.put("mail.smtp.auth", "true");

        props.put("mail.smtp.ssl.enable", "true");

        props.put("mail.smtp.ssl.trust", "smtp.gmail.com");

        props.put("mail.smtp.socketFactory.port", "465");

        props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");

        props.put("mail.smtp.connectiontimeout", "30000");

        props.put("mail.smtp.timeout", "120000");

        props.put("mail.smtp.writetimeout", "120000");

        return mailSender;

    }

    @Bean(name = "gson")

    public Gson gson() {

        Gson gson = new GsonBuilder().serializeNulls().registerTypeAdapter(LocalDateTime.class, new LocalDateTimeJsonConverter()).create();

        return gson;

    }

    @Bean(name = "veloctyEngine")

    public VelocityEngine velocityEngine() throws VelocityException, IOException {

        VelocityEngineFactoryBean factory = new VelocityEngineFactoryBean();

        // Properties props = new Properties();

        // props.put("resource.loader", "file");

        // props.put("file.resource.loader.description", "Velocity File Resource

        // Loader");

        // props.put("file.resource.loader.class",

        // "org.apache.velocity.runtime.resource.loader.FileResourceLoader");

        // props.put("file.resource.loader.cache", true);

        // props.put("file.resource.loader.path", ".");

        factory.setPreferFileSystemAccess(false);

        // factory.setResourceLoaderPath("classpath:/templates/");

        Properties velocityProperties = new Properties();

        velocityProperties.put("resource.loader", "class");

        velocityProperties.put("class.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");

        velocityProperties.put("file.resource.loader.cache", true);

        velocityProperties.put("file.resource.loader.unicode", true);

        velocityProperties.put("input.encoding", "UTF-8");

        velocityProperties.put("output.encoding", "UTF-8");

        velocityProperties.put("overrideLogging", true);

        velocityProperties.setProperty("input.encoding", "UTF-8");

        velocityProperties.setProperty("output.encoding", "UTF-8");

        factory.setVelocityProperties(velocityProperties);

        // velocityProperties.put("file.resource.loader.path", ".");

        factory.setVelocityProperties(velocityProperties);

        return factory.createVelocityEngine();

    }

    @Bean

    public ObjectMapper objectMapper() {

        DateTimeFormatter df = new DateTimeFormatterBuilder().parseCaseInsensitive().append(DateTimeFormatter.ISO_LOCAL_DATE).optionalStart().appendLiteral('T').optionalEnd().appendLiteral(' ').append(DateTimeFormatter.ISO_LOCAL_TIME).toFormatter();

        DateTimeFormatter sf = new DateTimeFormatterBuilder().parseCaseInsensitive().append(DateTimeFormatter.ISO_LOCAL_DATE).appendLiteral('T').append(DateTimeFormatter.ISO_LOCAL_TIME).toFormatter();

        DateTimeFormatter dateFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive().append(DateTimeFormatter.ISO_LOCAL_DATE).toFormatter();

        JavaTimeModule jtm = new JavaTimeModule();

        jtm.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(sf));

        jtm.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(df));

        jtm.addSerializer(LocalDate.class, new LocalDateSerializer(dateFormatter));

        jtm.addDeserializer(LocalDate.class, new LocalDateDeserializer(dateFormatter));

        SimpleModule stringModule = new SimpleModule("String trimmer deserialize module");

        stringModule.addDeserializer(String.class, new CustomStringDeserializer());

        ObjectMapper mapper = new ObjectMapper()

                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)

                .registerModule(new ParameterNamesModule()).registerModule(new Jdk8Module()).registerModule(jtm)

                .registerModule(stringModule); // new module, NOT JSR310Module

        return mapper;

    }

    class CustomStringDeserializer extends StringDeserializer implements ContextualDeserializer {

        // Fields whose exact bytes matter — never normalize (credentials, tokens, payloads).

        private final java.util.regex.Pattern SENSITIVE_FIELD =

                java.util.regex.Pattern.compile("(?i)(password|passwd|pwd|otp|pin|token|secret|signature|hash|base64|apikey|api_key)");

        private final boolean normalize;

        CustomStringDeserializer() {

            this(true);

        }

        CustomStringDeserializer(boolean normalize) {

            this.normalize = normalize;

        }

        @Override

        public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) {

            if (property != null && SENSITIVE_FIELD.matcher(property.getName()).find()) {

                return new CustomStringDeserializer(false);

            }

            return this;

        }

        @Override

        public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {

            String text = super.deserialize(p, ctxt);

            if (!normalize) {

                return text;

            }

            // trim + NBSP/tab/zero-width -> single space + collapse doubles

            return com.spice.profitmandi.common.util.StringUtils.normalizeWhitespace(text);

        }

    }

}