Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.sql.Timestamp;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.ZoneOffset;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import javax.transaction.Transactional;

import javax.xml.bind.DatatypeConverter;

import org.apache.commons.csv.CSVFormat;

import org.apache.commons.csv.CSVParser;

import org.apache.commons.csv.CSVRecord;

import org.apache.commons.lang3.StringUtils;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RequestPart;

import org.springframework.web.multipart.MultipartFile;

import com.google.gson.Gson;

import com.jcraft.jsch.ChannelSftp;

import com.jcraft.jsch.JSch;

import com.jcraft.jsch.JSchException;

import com.jcraft.jsch.Session;

import com.jcraft.jsch.SftpATTRS;

import com.jcraft.jsch.SftpException;

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

import com.spice.profitmandi.common.solr.SolrService;

import com.spice.profitmandi.dao.entity.catalog.Item;

import com.spice.profitmandi.dao.entity.dtr.DocumentUrl;

import com.spice.profitmandi.dao.model.ContentPojo;

import com.spice.profitmandi.dao.model.MediaPojo;

import com.spice.profitmandi.dao.model.Specification;

import com.spice.profitmandi.dao.model.SpecificationGroup;

import com.spice.profitmandi.dao.repository.catalog.ItemRepository;

import com.spice.profitmandi.dao.repository.dtr.DocumentUrlRepository;

import com.spice.profitmandi.dao.repository.dtr.Mongo;

import com.spice.profitmandi.web.model.EntityMediaPojo;

import com.spice.profitmandi.web.util.MVCResponseSender;

@Transactional(rollbackOn = Throwable.class)

@Controller

public class ContentController {

	@Autowired

	MVCResponseSender mvcResponseSender;

	@Autowired

	Mongo mongoClient;

	@Autowired

	SolrService solrService;

	@Autowired

	ItemRepository itemRepository;

	@Autowired

	DocumentUrlRepository documentUrlRepository;

	private Gson gson = new Gson();

	public static final int Entity_Id = 0;

	public static final int Title = 1;

	public static final int KeySpec1 = 2;

	public static final int KeySpec2 = 3;

	public static final int KeySpec3 = 4;

	public static final int KeySpec4 = 5;

	public static final int Warranty = 6;

	public static final int Package_Contents = 7;

	private static final String IMAGE_REMOTE_DIR = "/var/www/dtrdashboard/uploads/campaigns/";

	private static final String IMAGE_STATIC_SERVER_URL = "https://images.smartdukaan.com/uploads/campaigns";

	//private static final String REMOTE_DIR = "/var/www/static.saholic.com/images/media/";

	private static final String REMOTE_DIR = "/tmp";

	private static final String STATIC_SERVER_URL = "https://static%d.smartdukaan.com/images/media/";

	private static final String THUMBNAIL = "thumbnail";

	private static final String ICON = "icon";

	private static final String DEFAULT = "default";

	private static final String NONE = "";

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

	private String getFileName(int entityId, String description, String extension) {

		List<Item> items = itemRepository.selectAllByCatalogItemId(entityId);

		String imageString = getMediaPrefix(items.get(0).getItemDescriptionNoColor() + " " + description) + "-"

				+ LocalDateTime.now().toEpochSecond(ZoneOffset.ofHoursMinutes(5, 30));

		return imageString + "." + extension;

	}

	@PostMapping(value = "/content/upload")

	public String uploadContent(HttpServletRequest request, @RequestPart("file") MultipartFile file, Model model)

			throws Exception {

		List<ContentPojo> contentPojos = readFile(file);

		for (ContentPojo contentPojo : contentPojos) {

			mongoClient.persistEntity(contentPojo);

		}

		model.addAttribute("response", mvcResponseSender.createResponseString(true));

		return "response";

	}

	@PostMapping(value = "/content/media/upload")

	public String uploadMediaContent(HttpServletRequest request, @RequestBody EntityMediaPojo entityMediaPojo,

			Model model) throws Exception {

		ContentPojo contentPojo = mongoClient.getEntityById(entityMediaPojo.getEntityId());

		Map<String, InputStream> fileStreamsMap = getStreamFileMap(contentPojo, entityMediaPojo);

		LOGGER.info("fileStreamsMap {}, " + fileStreamsMap.keySet());

		uploadFiles(fileStreamsMap, entityMediaPojo.getEntityId());

		mongoClient.persistEntity(contentPojo);

		model.addAttribute("response", mvcResponseSender.createResponseString(true));

		return "response";

	}

	@PostMapping(value = "/image/media/upload")

	public String uploadImageMediaContent(HttpServletRequest request, @RequestBody MediaPojo mediaPojo, Model model)

			throws Exception {

		LOGGER.info("mediaPojo" + mediaPojo);

		Map<String, InputStream> fileStreamsMap = new HashMap<>();

		String extension;

		String base64String = mediaPojo.getImageData();

		String[] strings = base64String.split(",");

		switch (strings[0]) {// check image's extension

		case "data:image/jpeg;base64":

			extension = "jpeg";

			break;

		case "data:image/png;base64":

			extension = "png";

			break;

		default:// should write cases for more images types

			extension = ".jpg";

			break;

		}

		LOGGER.info("After switch statement = {}", extension);

		// convert base64 string to binary data

		byte[] data = DatatypeConverter.parseBase64Binary(strings[1]);

		Timestamp tm = new Timestamp(System.currentTimeMillis());

		String urlTitle = mediaPojo.getTitle().toLowerCase();

		String fileName = urlTitle.replace(' ', '-') + tm.getTime() + "." + extension;

		LOGGER.info("After switch statement Filename = {}", fileName);

		mediaPojo.setImageData(null);

		mediaPojo.setUrl(IMAGE_STATIC_SERVER_URL + "/" + "image" + LocalDate.now() + "/" + fileName);

		fileStreamsMap.put(fileName, new ByteArrayInputStream(data));

		LOGGER.info("fileStreamsMap" + fileStreamsMap);

		uploadFile(fileStreamsMap);

		DocumentUrl du = new DocumentUrl();

		du.setTitle(mediaPojo.getTitle());

		du.setUrl(mediaPojo.getUrl());

		du.setCreatedTimestamp(LocalDateTime.now());

		documentUrlRepository.persist(du);

		model.addAttribute("documents", du);

		return "image-url";

	}

	private void uploadFile(Map<String, InputStream> fileStreamsMap) throws Exception {

		ChannelSftp channelSftp = setupJsch();

		channelSftp.connect();

		this.fileUpload(channelSftp, fileStreamsMap, IMAGE_REMOTE_DIR + "");

		channelSftp.exit();

	}

	private void fileUpload(ChannelSftp channelSftp, Map<String, InputStream> streamsFileMap, String destinationPath)

			throws SftpException, FileNotFoundException {

		channelSftp.cd(destinationPath);

		String folderName = "image" + LocalDate.now();

		channelSftp.cd(destinationPath);

		SftpATTRS attrs = null;

		// check if the directory is already existing

		try {

			attrs = channelSftp.stat(folderName);

		} catch (Exception e) {

			System.out.println(destinationPath + "/" + "image" + LocalDate.now() + " not found");

		}

		// else create a directory

		if (attrs == null) {

			channelSftp.mkdir(folderName);

			channelSftp.chmod(0755, ".");

		}

		channelSftp.cd(folderName);

		for (Map.Entry<String, InputStream> streamsFileEntry : streamsFileMap.entrySet()) {

			channelSftp.put(streamsFileEntry.getValue(), streamsFileEntry.getKey(), ChannelSftp.OVERWRITE);

		}

	}

	@GetMapping(value = "/search/image/media")

	public String getImage(HttpServletRequest request, Model model, @RequestParam String title) throws Exception {

		List<DocumentUrl> documents = documentUrlRepository.selectBySearch(title);

		model.addAttribute("documents", documents);

		return "image-url";

	}

	@GetMapping(value = "/content/media")

	public String getMediaContent(HttpServletRequest request, Model model, @RequestParam int entityId)

			throws Exception {

		ContentPojo contentPojo = mongoClient.getEntityById(entityId);

		if (contentPojo == null) {

			throw new Exception("Please add content first");

		}

		EntityMediaPojo empojo = getEntityMediaPojo(contentPojo);

		model.addAttribute("response", mvcResponseSender.createResponseString(empojo));

		return "response";

	}

	@GetMapping(value = "/catalog-item")

	public String catalogItem(HttpServletRequest request, Model model) throws Exception {

		return "catalog-item";

	}

	private EntityMediaPojo getEntityMediaPojo(ContentPojo contentPojo) {

		EntityMediaPojo ep = new EntityMediaPojo();

		int defaultIndex = 0;

		if (contentPojo.getImages() == null) {

			ep.setMediaPojos(new ArrayList<>());

		} else {

			ep.setMediaPojos(contentPojo.getImages());

			for (MediaPojo mediaPojo : contentPojo.getImages()) {

				if (mediaPojo.getUrl() == null)

					continue;

				if (!mediaPojo.getUrl().equals(contentPojo.getDefaultImageUrl())) {

					defaultIndex++;

				}

			}

		}

		ep.setDefaultImageIndex(defaultIndex);

		return ep;

	}

	@GetMapping(value = "/entity")

	public String searchEntity(HttpServletRequest request, @RequestParam(defaultValue = "null") String query,

			@RequestParam(defaultValue = "0") int categoryId, @RequestParam(defaultValue = "") List<String> brands,

			@RequestParam(defaultValue = "30") int limit, Model model) throws Exception {

		model.addAttribute("response", solrService.getContent(query, categoryId, brands, limit));

		return "response";

	}

	@GetMapping(value = "/content/index")

	public String index(HttpServletRequest request, Model model) throws Exception {

		return "content";

	}

	private List<ContentPojo> readFile(MultipartFile file) throws Exception {

		CSVParser parser = new CSVParser(new InputStreamReader(file.getInputStream()), CSVFormat.DEFAULT);

		List<CSVRecord> records = parser.getRecords();

		if (records.size() < 2) {

			parser.close();

			throw new ProfitMandiBusinessException("Uploaded File", "", "No records Found");

		}

		// Remove header

		records.remove(0);

		List<ContentPojo> returnList = new ArrayList<ContentPojo>();

		for (CSVRecord record : records) {

			ContentPojo cp = null;

			Long entityId = Long.parseLong(record.get(Entity_Id));

			try {

				cp = mongoClient.getEntityById(entityId);

			} catch (Exception e) {

			}

			try {

				if (cp == null) {

					cp = new ContentPojo(entityId);

				}

				cp.setWarranty(record.get(Warranty));

				cp.setKeySpecs(Arrays

						.asList(record.get(KeySpec1), record.get(KeySpec2), record.get(KeySpec3), record.get(KeySpec4))

						.stream().filter(x -> x != null && !x.equals("")).collect(Collectors.toList()));

				cp.setPackageContents(Arrays.asList(record.get(Package_Contents).split(",")));

				cp.setDetailedSpecs(getDetailedSpecs(record));

				returnList.add(cp);

			} catch (Exception e) {

				continue;

			}

		}

		parser.close();

		return returnList;

	}

	private List<SpecificationGroup> getDetailedSpecs(CSVRecord record) throws Exception {

		List<SpecificationGroup> specificationGroups = new ArrayList<>();

		int currentIndex = 8;

		while (StringUtils.isNotEmpty(record.get(currentIndex))) {

			int start = currentIndex;

			List<Specification> specifications = new ArrayList<>();

			int begin = 0;

			while (begin < 5) {

				int specKeyIndex = (begin * 2) + 1;

				int specValueIndex = (begin * 2) + 2;

				if (StringUtils.isNotEmpty(record.get(currentIndex + specKeyIndex))

						&& StringUtils.isNotEmpty(record.get(currentIndex + specValueIndex))) {

					Specification specification = new Specification(record.get(currentIndex + specKeyIndex),

							Arrays.asList(record.get(currentIndex + specValueIndex)));

					specifications.add(specification);

				}

				begin++;

			}

			SpecificationGroup specificationGroup = new SpecificationGroup(record.get(start), specifications);

			specificationGroups.add(specificationGroup);

			currentIndex += 11;

		}

		return specificationGroups;

	}

	private ChannelSftp setupJsch() throws JSchException {

		JSch jsch = new JSch();

		Session jschSession = jsch.getSession("root", "192.168.179.131");

		//Session jschSession = jsch.getSession("root", "173.255.254.24");

		LOGGER.info("getClass().getResource(\"id_rsa\") {}", getClass().getClassLoader().getResource("id_rsa").getPath());

		jsch.addIdentity(getClass().getClassLoader().getResource("id_rsa").getPath());

		//jschSession.setPassword("spic@2015static0");

		jschSession.setConfig("StrictHostKeyChecking", "no");

		jschSession.connect();

		return (ChannelSftp) jschSession.openChannel("sftp");

	}

	private void uploadFiles(Map<String, InputStream> fileStreamsMap, int entityId) throws Exception {

		ChannelSftp channelSftp = setupJsch();

		channelSftp.connect();

		this.folderUpload(channelSftp, fileStreamsMap, REMOTE_DIR, entityId + "");

		channelSftp.exit();

	}

	private void recursiveFolderUpload(ChannelSftp channelSftp, String sourcePath, String destinationPath)

			throws SftpException, FileNotFoundException {

		File sourceFile = new File(sourcePath);

		if (sourceFile.isFile()) {

			// copy if it is a file

			channelSftp.cd(destinationPath);

			if (!sourceFile.getName().startsWith("."))

				channelSftp.put(new FileInputStream(sourceFile), sourceFile.getName(), ChannelSftp.OVERWRITE);

		} else {

			System.out.println("inside else " + sourceFile.getName());

			File[] files = sourceFile.listFiles();

			if (files != null && !sourceFile.getName().startsWith(".")) {

				channelSftp.cd(destinationPath);

				SftpATTRS attrs = null;

				// check if the directory is already existing

				try {

					attrs = channelSftp.stat(destinationPath + "/" + sourceFile.getName());

				} catch (Exception e) {

					System.out.println(destinationPath + "/" + sourceFile.getName() + " not found");

				}

				// else create a directory

				if (attrs != null) {

					System.out.println("Directory exists IsDir=" + attrs.isDir());

				} else {

					System.out.println("Creating dir " + sourceFile.getName());

					channelSftp.mkdir(sourceFile.getName());

				}

				for (File f : files) {

					recursiveFolderUpload(channelSftp, f.getAbsolutePath(),

							destinationPath + "/" + sourceFile.getName());

				}

			}

		}

	}

	private void folderUpload(ChannelSftp channelSftp, Map<String, InputStream> streamsFileMap, String destinationPath,

			String folderName) throws SftpException, FileNotFoundException {

		channelSftp.cd(destinationPath);

		SftpATTRS attrs = null;

		// check if the directory is already existing

		try {

			attrs = channelSftp.stat(folderName);

		} catch (Exception e) {

			System.out.println(destinationPath + "/" + folderName + " not found");

		}

		// else create a directory

		if (attrs == null) {

			channelSftp.mkdir(folderName);

			channelSftp.chmod(0755, ".");

		}

		channelSftp.cd(folderName);

		channelSftp.rm("*");

		for (Map.Entry<String, InputStream> streamsFileEntry : streamsFileMap.entrySet()) {

			channelSftp.put(streamsFileEntry.getValue(), streamsFileEntry.getKey(), ChannelSftp.OVERWRITE);

		}

	}

	private Map<String, InputStream> getStreamFileMap(ContentPojo contentPojo, EntityMediaPojo entityMediaPojo) {

		Map<String, InputStream> map = new HashMap<>();

		LOGGER.info("entityMediaPojo.getMediaPojos() -[{}]", entityMediaPojo.getMediaPojos());

		for (int i = 0; i < entityMediaPojo.getMediaPojos().size(); i++) {

			MediaPojo mediaPojo = entityMediaPojo.getMediaPojos().get(i);

			String extension;

			String base64String = mediaPojo.getImageData();

			String[] strings = base64String.split(",");

			switch (strings[0]) {// check image's extension

			case "data:image/jpeg;base64":

				extension = "jpeg";

				break;

			case "data:image/png;base64":

				extension = "png";

				break;

			default:// should write cases for more images types

				extension = "jpg";

				break;

			}

			LOGGER.info("After switch statement = {}", extension);

			// convert base64 string to binary data

			byte[] data = DatatypeConverter.parseBase64Binary(strings[1]);

			String fileName = getFileName(entityMediaPojo.getEntityId(), mediaPojo.getTitle(), extension);

			LOGGER.info("After switch statement Filename = {}", fileName);

			mediaPojo.setImageData(null);

			String staticServerUrl = String.format(STATIC_SERVER_URL, entityMediaPojo.getEntityId() % 3);

			mediaPojo.setUrl(staticServerUrl + entityMediaPojo.getEntityId() + "/" + fileName);

			map.put(fileName, new ByteArrayInputStream(data));

			if (i == entityMediaPojo.getDefaultImageIndex()) {

				String defaultFileName = getFileName(entityMediaPojo.getEntityId(), DEFAULT, extension);

				map.put(defaultFileName, new ByteArrayInputStream(data));

				contentPojo.setDefaultImageUrl(staticServerUrl + entityMediaPojo.getEntityId() + "/" + defaultFileName);

			}

		}

		contentPojo.setImages(entityMediaPojo.getMediaPojos());

		return map;

	}

	private String getMediaPrefix(String productName) {

		String mediaPrefix = productName.toLowerCase().replace(' ', '-');

		mediaPrefix = mediaPrefix.replaceAll("/", "-");

		mediaPrefix = mediaPrefix.replaceAll("-+", "-");

		return mediaPrefix;

	}

	@GetMapping(value = "/urlGeneration")

	public String urlGeneration(HttpServletRequest request, Model model) throws Exception {

		return "url-generation";

	}

}