Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.config;

import java.io.IOException;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.Properties;

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 com.spice.profitmandi.common.services.AuthenticatedIdentityMailSender;

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

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

import org.springframework.mail.javamail.JavaMailSenderImpl;

import org.springframework.ui.velocity.VelocityEngineFactoryBean;

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

import com.google.gson.Gson;

import com.google.gson.GsonBuilder;

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

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

@Configuration

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

public class AppConfig {

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

	private static final String PATH_SUFFIX = ".jsp";

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

	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(name = "viewResolver") public InternalResourceViewResolver

	 * getViewResolver() { LOGGER.debug("creating view resolver bean with prefix : "

	 * + PATH_PREFIX + " and suffix : " + PATH_SUFFIX); InternalResourceViewResolver

	 * viewResolver = new InternalResourceViewResolver();

	 * viewResolver.setPrefix(PATH_PREFIX); viewResolver.setSuffix(PATH_SUFFIX);

	 * return viewResolver; }

	 */

	@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);

		return messageSource;

	}

	@Bean(name = "multipartResolver")

	public CommonsMultipartResolver getCommonsMultipartResolver() {

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

		CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();

		multipartResolver.setMaxUploadSizePerFile(5000000);

		multipartResolver.setMaxUploadSize(5000000);

		return multipartResolver;

	}

	@Bean

	public PropertySourcesPlaceholderConfigurer propertyConfigurer1() {

		String activeProfile;

		PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new PropertySourcesPlaceholderConfigurer();

		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");

		}

		activeProfile = (String) properties.get("profile");

		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;

	}

	/**

	 * 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;

	}

	/**

	 * 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;

	}

	@Bean(name = "gson")

	public Gson gson() {

		Gson gson = new GsonBuilder().setPrettyPrinting().serializeNulls()

				.registerTypeAdapter(LocalDate.class, new LocalDateJsonConverter())

				.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", ".");

		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.put("file.resource.loader.path", ".");

		factory.setVelocityProperties(velocityProperties);

		return factory.createVelocityEngine();

	}

}