Subversion Repositories SmartDukaan

package com.spice.profitmandi.common.util;

import com.google.gson.Gson;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.web.client.RestClient;

import com.spice.profitmandi.thrift.clients.CatalogClient;

import com.spice.profitmandi.thrift.clients.InventoryClient;

import com.spice.profitmandi.thrift.clients.TransactionClient;

import com.spice.profitmandi.thrift.clients.WarehouseClient;

import in.shop2020.model.v1.catalog.CatalogService;

import in.shop2020.model.v1.inventory.InventoryService;

import in.shop2020.model.v1.inventory.StateInfo;

import in.shop2020.model.v1.inventory.Warehouse;

import in.shop2020.model.v1.order.OrderStatusGroups;

import in.shop2020.model.v1.order.RechargeOrderStatus;

import in.shop2020.model.v1.order.RechargePlan;

import in.shop2020.model.v1.order.WarehouseAddress;

import in.shop2020.warehouse.InventoryItem;

import in.shop2020.warehouse.WarehouseService;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.StringEscapeUtils;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.core.io.InputStreamSource;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.mail.javamail.MimeMessageHelper;

import javax.mail.Multipart;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeBodyPart;

import javax.mail.internet.MimeMessage;

import javax.mail.internet.MimeMultipart;

import java.io.File;

import java.io.IOException;

import java.io.Serializable;

import java.time.*;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Utils {

	public static final float FLOAT_EPSILON = 0.001f;

	public static final double DOUBLE_EPSILON = 0.001d;

	private static final Logger logger = LogManager.getLogger(Utils.class);

	public static final String EXPORT_ENTITIES_PATH = getExportPath();

	public static final String PRODUCT_PROPERTIES_SNIPPET = "ProductPropertiesSnippet.html";

	public static final String DOCUMENT_STORE = "/profitmandi/documents/";

	private Gson gson = new Gson();

	private static final Map<Integer, String> helpMap = new HashMap<>(6);

	private static final Map<Integer, String> dthIdAliasMap = new HashMap<>(7);

	private static Map<Long, List<RechargePlan>> operatorPlanMap = new HashMap<>(20);

	private static Map<Long, String> mobileProvidersMap;

	private static Map<Long, String> dthProvidersMap;

	private static Map<Long, String> allProviders;

	public static Map<RechargeOrderStatus, String> rechargeStatusMap = new HashMap<>();

	public static OrderStatusGroups ORDER_STATUS_GROUPS = new OrderStatusGroups();

	public static final String SYSTEM_PARTNER = "testpxps@gmail.com";

	public static final int SYSTEM_PARTNER_ID = 175120474;

	private static final RestClient rc = new RestClient();

	private static final String regex = "^[a-zA-Z0-9_!#$%&'*+/=?`{|}~^.-]+@[a-zA-Z0-9.-]+$";

	public static final LocalTime MAX_TIME = LocalTime.of(23, 59, 59);

	// Compile regular expression to get the pattern

	private static final Pattern pattern = Pattern.compile(regex);

	public static boolean validateEmail(String email) {

		if (email == null) {

			return false;

		}

		Matcher matcher = pattern.matcher(email);

		return matcher.matches();

	}

	@SuppressWarnings("serial")

	public static final Map<String, String> MIME_TYPE = Collections.unmodifiableMap(new HashMap<String, String>() {

		{

			put("image/png", "png");

			put("image/jpeg", "jpeg");

			put("image/pjpeg", "jpeg");

			put("application/pdf", "pdf");

			put("application/msword", "doc");

			put("application/vnd.openxmlformats-officedocument.wordprocessingml.document", "docx");

			put("application/vnd.ms-excel", "xls");

			put("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xlsx");

		}

	});

	private static String getExportPath() {

		String exportPath = "/var/lib/tomcat7/webapps/export/html/entities/";

		/*

		 * String exportPath = null;

		 * 

		 * try { ConfigClient client = ConfigClient.getClient(); exportPath =

		 * client.get("export_entities_path"); } catch (Exception ce) {

		 * logger.error("Unable to read export path from the config client: ", ce);

		 * logger.warn("Setting the default export path"); exportPath =

		 * "/var/lib/tomcat7/webapps/export/html/entities/"; }

		 */

		return exportPath;

	}

	public static LocalDateTime toLocalDateTime(long epochTimeInMillis) {

		return LocalDateTime.ofInstant(Instant.ofEpochMilli(epochTimeInMillis), ZoneId.systemDefault());

	}

	public static String getRechargeDisplayStatus(RechargeOrderStatus status) {

		if (status == null) {

			status = RechargeOrderStatus.INIT;

		}

		String displayStatus = (String) rechargeStatusMap.get(status);

		if (displayStatus == null) {

			return "";

		}

		return displayStatus;

	}

	public static boolean copyDocument(String documentPath) {

		File source = new File(documentPath);

		File dest = new File(DOCUMENT_STORE + source.getName());

		try {

			FileUtils.copyFile(source, dest);

		} catch (IOException e) {

			e.printStackTrace();

			return false;

		}

		return true;

	}

	public static Map<Long, String> getMobileProvidersMap() {

		return mobileProvidersMap;

	}

	public static Map<Long, String> getDthProvidersMap() {

		return dthProvidersMap;

	}

	public static Map<Long, String> getAllProviders() {

		return allProviders;

	}

	public static String getProvider(long operatorId) {

		return allProviders.get(operatorId);

	}

	public static void sendSms(String text, String mobileNumber) throws Exception {

		Map<String, String> paramsMap = new HashMap<>();

		paramsMap.put("username", "SmartDukaanT");

		paramsMap.put("password", "Smart@91");

		paramsMap.put("senderID", "SMTDKN");

		paramsMap.put("message", text);

		paramsMap.put("mobile", mobileNumber);

		paramsMap.put("messageType", "Text");

		// rc.getResponse(SMS_GATEWAY, paramsMap, null);

	}

	public static void sendMailWithAttachments(JavaMailSender mailSender, String emailTo, String[] cc, String subject,

			String body, List<File> attachments) throws Exception {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message, true);

		helper.setSubject(subject);

		helper.setText(body);

		if (cc != null) {

			helper.setCc(cc);

		}

		helper.setTo(emailTo);

		// helper.setTo("amit.gupta@smartdukaan.com");

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "SmartDukaan Care");

		helper.setFrom(senderAddress);

		if (attachments != null) {

			for (File file : attachments) {

				helper.addAttachment(file.getName(), file);

			}

		}

		mailSender.send(message);

	}

	public static class Attachment {

		public Attachment(String fileName, InputStreamSource inputStreamSource) {

			this.fileName = fileName;

			this.inputStreamSource = inputStreamSource;

		}

		private String fileName;

		private InputStreamSource inputStreamSource;

		public String getFileName() {

			return fileName;

		}

		public void setFileName(String fileName) {

			this.fileName = fileName;

		}

		public InputStreamSource getInputStreamSource() {

			return inputStreamSource;

		}

		public void setInputStreamSource(InputStreamSource inputStreamSource) {

			this.inputStreamSource = inputStreamSource;

		}

		@Override

		public String toString() {

			return "Attachment [fileName=" + fileName + ", inputStreamSource=" + inputStreamSource + "]";

		}

	}

	public static void sendMailWithAttachment(JavaMailSender mailSender, String[] emailTo, String[] cc, String subject,

			String body, String fileName, InputStreamSource inputStreamSource) throws Exception {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message, true);

		helper.setSubject(subject);

		helper.setText(body);

		if (cc != null) {

			helper.setCc(cc);

		}

		helper.setTo(emailTo);

		helper.addAttachment(fileName, inputStreamSource);

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "SmartDukaan Care");

		helper.setFrom(senderAddress);

		mailSender.send(message);

	}

	public static void sendMailWithAttachments(JavaMailSender mailSender, String[] emailTo, String[] cc, String[] bcc,

			String subject, String body, Attachment... attachments) throws Exception {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message, true);

		helper.setSubject(subject);

		helper.setText(body);

		if (cc != null) {

			helper.setCc(cc);

		}

		if (bcc != null) {

			helper.setBcc(bcc);

		}

		helper.setTo(emailTo);

		for (Attachment attachment : attachments) {

			helper.addAttachment(attachment.getFileName(), attachment.getInputStreamSource());

		}

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "SmartDukaan Care");

		helper.setFrom(senderAddress);

		mailSender.send(message);

	}

	public static void sendHtmlMailWithAttachments(JavaMailSender mailSender, String[] emailTo, String[] cc,

			String subject, String body, Attachment... attachments) throws Exception {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message, true);

		helper.setSubject(subject);

		helper.setText(body, true);

		// helper.setText(body, true);

		if (cc != null) {

			helper.setCc(cc);

		}

		helper.setTo(emailTo);

		for (Attachment attachment : attachments) {

			if (attachment == null)

				break;

			helper.addAttachment(attachment.getFileName(), attachment.getInputStreamSource());

		}

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "SmartDukaan Care");

		helper.setFrom(senderAddress);

		mailSender.send(message);

	}

	public static String[] getOrderStatus(RechargeOrderStatus status) {

		if (status == null) {

			status = RechargeOrderStatus.INIT;

		}

		if (status.equals(RechargeOrderStatus.PAYMENT_FAILED) || status.equals(RechargeOrderStatus.PAYMENT_PENDING)) {

			return new String[] { "false", "PAYMENT FAILED", "Payment failed at the payment gateway." };

		} else if (status.equals(RechargeOrderStatus.PAYMENT_SUCCESSFUL)

				|| status.equals(RechargeOrderStatus.RECHARGE_UNKNOWN)) {

			if (status.equals(RechargeOrderStatus.PAYMENT_SUCCESSFUL)) {

				return new String[] { "false", "PAYMENT SUCCESSFUL",

						"Your Payment was successful but due to some internal error with the operator's system we are not sure if the recharge was successful."

								+ " We have put your recharge under process."

								+ " As soon as we get a confirmation on this transaction, we will notify you." };

			} else {

				return new String[] { "false", "RECHARGE IN PROCESS",

						"Your Payment is successful.We have put your recharge under process."

								+ " Please wait while we check with the operator." };

			}

		} else if (status.equals(RechargeOrderStatus.RECHARGE_FAILED)

				|| status.equals(RechargeOrderStatus.RECHARGE_FAILED_REFUNDED)) {

			return new String[] { "false", "RECHARGE FAILED",

					"Your Payment was successful but unfortunately the recharge failed.Don't worry your payment is safe with us."

							+ " The entire Amount has been refunded to your wallet." };

		} else if (status.equals(RechargeOrderStatus.RECHARGE_SUCCESSFUL)) {

			return new String[] { "false", "SUCCESS", "Congratulations! Your device is successfully recharged." };

		} else if (status.equals(RechargeOrderStatus.PARTIALLY_REFUNDED)

				|| status.equals(RechargeOrderStatus.REFUNDED)) {

			return new String[] { "false", "PAYMENT REFUNDED",

					"The payment associated with this recharge order has been refunded." };

		} else {

			return new String[] { "true", "ERROR", "INVALID INPUT" };

		}

	}

	public static String getIconUrl(int entityId, String host, int port, String webapp) {

		return "";

	}

	private static CatalogService.Client getCatalogClient() throws Exception {

		try {

			CatalogClient client = new CatalogClient();

			CatalogService.Client catalogClient = client.getClient();

			return catalogClient;

		} catch (Exception e) {

			throw e;

		}

	}

	private static WarehouseService.Client getWarehouseClient() throws Exception {

		try {

			WarehouseClient client = new WarehouseClient();

			WarehouseService.Client warehouseClient = client.getClient();

			return warehouseClient;

		} catch (Exception e) {

			throw e;

		}

	}

	public static Map<String, Warehouse> getWarehouseByImeis(List<String> imeis) throws Exception {

		List<InventoryItem> inventoryItems = getWarehouseClient().getInventoryItemsBySerailNumbers(imeis);

		Map<String, InventoryItem> imeiInventoryItemMap = new HashMap<>();

		for (InventoryItem inventoryItem : inventoryItems) {

			imeiInventoryItemMap.put(inventoryItem.getSerialNumber(), inventoryItem);

		}

		Map<Integer, Warehouse> warehouseMap = new HashMap<>();

		Map<String, Warehouse> serialNumberWarehouseMap = new HashMap<>();

		InventoryClient client = new InventoryClient();

		InventoryService.Client inventoryClient = client.getClient();

		logger.info("[imeiInventoryItemMap] {}", imeiInventoryItemMap);

		for (InventoryItem inventory : new HashSet<>(imeiInventoryItemMap.values())) {

			Warehouse phWarehouse = null;

			if (warehouseMap.containsKey(inventory.getPhysicalWarehouseId())) {

				phWarehouse = warehouseMap.get((int) inventory.getPhysicalWarehouseId());

			} else {

				phWarehouse = inventoryClient.getWarehouse(inventory.getPhysicalWarehouseId());

				warehouseMap.put((int) inventory.getPhysicalWarehouseId(), phWarehouse);

			}

			serialNumberWarehouseMap.put(inventory.getSerialNumber(), phWarehouse);

		}

		return serialNumberWarehouseMap;

	}

	public static Map<Integer, Warehouse> getWarehousesByIds(Set<Integer> warehouseIds) throws Exception {

		InventoryClient client = new InventoryClient();

		InventoryService.Client inventoryClient = client.getClient();

		Map<Integer, Warehouse> warehouseMap = new HashMap<>();

		for (Integer warehouseId : warehouseIds) {

			warehouseMap.put(warehouseId, inventoryClient.getWarehouse(warehouseId));

		}

		return warehouseMap;

	}

	public static String getStateCode(String stateName) throws Exception {

		return getStateInfo(stateName).getStateCode();

	}

	public static long getStateId(String stateName) throws ProfitMandiBusinessException {

		try {

			return getStateInfo(stateName).getId();

		} catch (Exception e) {

			e.printStackTrace();

			throw new ProfitMandiBusinessException("State Name", stateName, "Could not fetch state");

		}

	}

	public static StateInfo getStateByStateId(long stateId) throws Exception {

		InventoryClient client = new InventoryClient();

		InventoryService.Client inventoryClient = client.getClient();

		Map<Long, StateInfo> map = inventoryClient.getStateMaster();

		return map.get(stateId);

	}

	public static StateInfo getStateInfo(String stateName) throws Exception {

		try {

			InventoryClient client = new InventoryClient();

			InventoryService.Client inventoryClient = client.getClient();

			Map<Long, StateInfo> map = inventoryClient.getStateMaster();

			List<StateInfo> stateInfos = new ArrayList<>(map.values());

			logger.info("State Name: {}", stateName);

			for (StateInfo stateInfo : stateInfos) {

				logger.info("State Name from service: {}", stateInfo.getStateName());

				if (stateName.toUpperCase().equals(stateInfo.getStateName().toUpperCase())) {

					return stateInfo;

				}

			}

			throw new Exception("Not found");

		} catch (Exception e) {

			e.printStackTrace();

			throw e;

		}

	}

	public static void main(String[] args) throws Exception {

		Utils.sendSms("Hello", "9990381569");

	}

	public static WarehouseAddress getWarehouseByWarehouseId(int warehouseAddressId) throws Exception {

		TransactionClient tcl = new TransactionClient();

		return tcl.getClient().getWarehouseAddress((long) warehouseAddressId);

	}

	public static void sendEmbeddedHtmlMail(JavaMailSender mailSender, String[] emailTo, String[] cc, String subject,

			String body, Map<? extends Serializable, File> map) throws Exception {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message, true);

		helper.setSubject(subject);

		Multipart mp = new MimeMultipart();

		MimeBodyPart messageBodyPart = new MimeBodyPart();

		messageBodyPart.setContent(body, "text/html");

		mp.addBodyPart(messageBodyPart);

		// helper.setText(body, true);

		if (cc != null) {

			helper.setCc(cc);

		}

		helper.setTo(emailTo);

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "SmartDukaan Care");

		helper.setFrom(senderAddress);

		for (Map.Entry<? extends Serializable, File> entry : map.entrySet()) {

			entry.getKey();

			entry.getValue();

			MimeBodyPart imagePart = new MimeBodyPart();

			imagePart.setHeader("Content-ID", entry.getKey() + "");

			imagePart.setDisposition(MimeBodyPart.INLINE);

			imagePart.attachFile(entry.getValue());

			mp.addBodyPart(imagePart);

		}

		message.setContent(mp);

		mailSender.send(message);

	}

	public String html(String string) {

		return org.apache.commons.lang.StringEscapeUtils.escapeHtml(String.valueOf(string));

	}

	public String htmlJson(Object object) {

		return StringEscapeUtils.escapeHtml4(gson.toJson(object));

	}

	public static String getHyphenatedString(String s) {

		s = s.trim().replaceAll("\\s+", " ");

		s = s.replaceAll("\\s", "-");

		return s.toLowerCase();

	}

	public static void sendMailWithAttachments(JavaMailSender mailSender, String[] emailTo, String[] cc, String subject,

			String body, Attachment... attachments) throws Exception {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message, true);

		helper.setSubject(subject);

		helper.setText(body);

		if (cc != null) {

			helper.setCc(cc);

		}

		helper.setTo(emailTo);

		for (Attachment attachment : attachments) {

			helper.addAttachment(attachment.getFileName(), attachment.getInputStreamSource());

		}

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "SmartDukaan Care");

		helper.setFrom(senderAddress);

		mailSender.send(message);

	}

	public static int compareFloat(float f1, float f2) {

		if ((f1 - f2 < FLOAT_EPSILON) || (f1 - f2 < -FLOAT_EPSILON)) {

			return 0;

		}

		return Float.compare(f1, f2);

	}

	public static int compareDouble(double d1, double d2) {

		if ((d1 - d2 < DOUBLE_EPSILON) || (d1 - d2 < -DOUBLE_EPSILON)) {

			return 0;

		}

		return Double.compare(d1, d2);

	}

	public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {

		Set<Object> seen = ConcurrentHashMap.newKeySet();

		return t -> seen.add(keyExtractor.apply(t));

	}

	public static <T> Predicate<T> smallestByKey(Function<? super T, ?> keyExtractor) {

		Set<Object> seen = ConcurrentHashMap.newKeySet();

		return t -> seen.add(keyExtractor.apply(t));

	}

	public static LocalDate convertToLocalDate(Date dateToConvert) {

		return Instant.ofEpochMilli(dateToConvert.getTime())

				.atZone(ZoneId.systemDefault())

				.toLocalDate();

	}

	public static LocalDateTime convertToLocalDateTime(Date dateToConvert) {

		return Instant.ofEpochMilli(dateToConvert.getTime())

				.atZone(ZoneId.systemDefault())

				.toLocalDateTime();

	}

}