Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.fasterxml.jackson.core.type.TypeReference;

import com.fasterxml.jackson.databind.DeserializationFeature;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.dataformat.xml.XmlMapper;

import com.spice.profitmandi.service.reportico.ReporticoService;

import com.spice.profitmandi.service.SshServer.SSHService;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

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

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

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

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

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

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

import org.springframework.web.client.RestTemplate;

import java.io.InputStream;

import java.net.URL;

import java.util.List;

import java.util.Map;

@Controller

@RequestMapping("/reportico")

public class ReporticoController {

    @Value("https://reports.smartdukaan.com/reports/projects/")

    private String host;

    @Qualifier("SSHServiceImpl")

    @Autowired

    private SSHService sshService;

    @Autowired

    private ReporticoService reporticoService;

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

    private final RestTemplate restTemplate = new RestTemplate();

    @GetMapping

    public String listReports(@RequestParam(value = "directory", required = false) String directoryName, Model model){

        try {

            if (directoryName == null || directoryName.isEmpty()) {

                directoryName = "/var/www/reports/projects";

            }

            Map<String, List<String>> fileList = sshService.readDirectory(directoryName);

            LOGGER.info("List of directories and files: {}",fileList);

            model.addAttribute("directories", fileList);

        } catch (Exception e) {

            LOGGER.error("Catches Error", e);

        }

        return "reportico/index";

    }

    @GetMapping("/file-content")

    public String convertXml(@RequestParam String path, Model model) throws Exception {

        String xmlString = restTemplate.getForObject(host+path, String.class);

        String content = convertXmlToJson(xmlString);

        model.addAttribute("content",content);

        return "reportico/content";

    }

    private String convertXmlToJson(String xmlString) throws Exception {

        XmlMapper xmlMapper = new XmlMapper();

        xmlMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

        ObjectMapper objectMapper = new ObjectMapper();

        Map<String, Object> map = xmlMapper.readValue(xmlString, new TypeReference<Map<String, Object>>() {});

        return objectMapper.writeValueAsString(map);

    }

    /*@GetMapping("/file-content")

    public String xmlReader(@RequestParam String path,Model model) throws Exception {

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        DocumentBuilder builder = factory.newDocumentBuilder();

        try {

            Document document = builder.parse(host+path);

            document.getDocumentElement().normalize();

            String sql = getTagValue(document, "SQLRaw");

            model.addAttribute("title",getTagValue(document, "ReportTitle"));

            model.addAttribute("source",getTagValue(document, "SourceType"));

            model.addAttribute("displayOrders",getTagValuesInMap(document, "DisplayOrder", "ColumnName", "OrderNumber"));

            model.addAttribute("Criteria",getTagValuesInMap(document, "CriteriaItem", "CriteriaType", "CriteriaDisplay"));

            model.addAttribute("sql",sql);

            model.addAttribute("result",executeQuery(sql));

        } catch (Exception e) {

            LOGGER.info("catch xml content", e);

            model.addAttribute("title", e.getMessage());

        }

        return "reportico/content";

    }

    public List<List<String>> executeQuery(String query) throws Exception {

        return reporticoService.executeCustomQuery(query);

    }

    private static String getTagValue(Document doc, String tagName) {

        NodeList nodeList = doc.getElementsByTagName(tagName);

        if (nodeList != null && nodeList.getLength() > 0) {

            Element element = (Element) nodeList.item(0);

            return element.getTextContent();

        }

        return null;

    }

    public static Map<String, Map<String, String>> getTagValuesInMap(Document doc, String parentName, String childTag, String childTagValue) {

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

        NodeList displayOrderNodes = doc.getElementsByTagName(parentName);

        for (int i = 0; i < displayOrderNodes.getLength(); i++) {

            Node node = displayOrderNodes.item(i);

            if (node.getNodeType() == Node.ELEMENT_NODE) {

                Element displayOrderElement = (Element) node;

                String columnName = displayOrderElement.getElementsByTagName(childTag).item(0).getTextContent().trim();

                String orderNumber = displayOrderElement.getElementsByTagName(childTagValue).item(0).getTextContent().trim();

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

                values.put(childTagValue, orderNumber);

                displayOrderMap.put(columnName, values);

            }

        }

        return displayOrderMap;

    }*/

}