$.MessageController.java Source code

Java tutorial

Introduction

Here is the source code for $.MessageController.java

Source

    #set($symbol_pound='#')#set($symbol_dollar='$')#set($symbol_escape='\')
    /*
     * Copyright (C) 2015
     * This program is free software: you can redistribute it and/or modify
     * it under the terms of the GNU General Public License as published by
     * the Free Software Foundation, either version 3 of the License, or
     * (at your option) any later version.
     *
     * This program is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     * GNU General Public License for more details.
     *
     * You should have received a copy of the GNU General Public License
     * along with this program.  If not, see <http://www.gnu.org/licenses/>.
     */

package ${package}.web.msg;

    import static org.springframework.util.StringUtils.hasText;

    import java.io.IOException;
    import java.io.StringWriter;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.SortedSet;
    import java.util.TreeSet;

    import org.cleverbus.api.entity.Message;
    import org.cleverbus.common.log.Log;
    import org.cleverbus.modules.ExternalSystemEnum;
    import org.cleverbus.spi.msg.MessageService;

    import org.apache.commons.lang.StringUtils;
    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.XMLWriter;
    import org.joda.time.LocalDate;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.ui.ModelMap;
    import org.springframework.web.bind.annotation.ModelAttribute;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RequestParam;

    /**
     * Controller that encapsulates actions around messages.
     *
     * @author <a href="mailto:petr.juza@cleverlance.com">Petr Juza</a>
     * @author <a href="mailto:tomas.hanus@cleverlance.com">Tomas Hanus</a>
     */
    @Controller
    @RequestMapping("/messages")
    public class MessageController {

        @Autowired
        private MessageService messageService;

        @Autowired
        private MessageLogParser messageLogParser;

        @RequestMapping(value = "/{msgId}", method = RequestMethod.GET)
        public String getMsgDetailByMsgId(@PathVariable("msgId") Long msgId, Model model) {
            Message msg = messageService.findEagerMessageById(msgId);

            model.addAttribute("requestMsgId", msgId);

            if (msg != null) {
                // pretty-print envelope
                if (StringUtils.isNotEmpty(msg.getEnvelope())) {
                    msg.setEnvelope(prettyPrintXML(msg.getEnvelope()));
                }
                // pretty-print payload
                if (StringUtils.isNotEmpty(msg.getPayload())) {
                    msg.setPayload(prettyPrintXML(msg.getPayload()));
                }

                model.addAttribute("msg", msg);
            }

            return "msg";
        }

        @RequestMapping(value = "/{msgId}/log", method = RequestMethod.GET)
        public String getLogOfMsgByMsgId(@PathVariable("msgId") Long msgId, Model model) {
            Message msg = messageService.findMessageById(msgId);

            model.addAttribute("requestMsgId", msgId);

            if (msg != null) {
                String correlationId = msg.getCorrelationId();

                model.addAttribute("correlationId", correlationId);

                List<String> logLines = new ArrayList<String>();
                try {
                    long start = System.currentTimeMillis();
                    SortedSet<LocalDate> logDates = getMsgDates(msg);
                    logDates.add(new LocalDate()); // adding today just in case

                    Log.debug("Starts searching log for correlationId = " + correlationId);

                    for (LocalDate logDate : logDates) {
                        logLines.addAll(messageLogParser.getLogLines(correlationId, logDate.toDate()));
                    }

                    Log.debug("Finished searching log in " + (System.currentTimeMillis() - start) + " ms.");

                    model.addAttribute("log", StringUtils.join(logLines, "${symbol_escape}n"));
                } catch (IOException ex) {
                    model.addAttribute("logErr", "Error occurred during reading log file: " + ex.getMessage());
                }
            }

            return "msgLog";
        }

        /**
         * Creates a set of message dates, to search logs for these dates.
         * This set contains just the dates of the following timestamps:
         * <ul>
         * <li>source system timestamp</li>
         * <li>received timestamp</li>
         * <li>start processing timestamp</li>
         * <li>last update timestamp</li>
         * </ul>
         * It's a Set, so that only distinct dates will be included.
         * It's a SortedSet, so that the dates are in their natural order.
         * The elements are LocalDate (without time),
         * so that the dates will be in the correct order
         * and the set will correctly not include duplicates.
         *
         * @param msg the message to find dates for
         * @return a set of dates
         */
        private SortedSet<LocalDate> getMsgDates(Message msg) {
            TreeSet<LocalDate> logDates = new TreeSet<LocalDate>();
            Date[] msgDates = new Date[] { msg.getMsgTimestamp(), msg.getReceiveTimestamp(),
                    msg.getStartProcessTimestamp(), msg.getLastUpdateTimestamp() };
            for (Date msgDate : msgDates) {
                if (msgDate != null) {
                    logDates.add(new LocalDate(msgDate));
                }
            }
            return logDates;
        }

        @RequestMapping(value = "/searchForm", method = RequestMethod.GET)
        public String getSearchForm(@RequestParam(value = "source", required = false) ExternalSystemEnum sourceSystem,
                @RequestParam(value = "correlation", required = false) String correlationId,
                @ModelAttribute("model") ModelMap model) {

            addExternalSystemsIntoModel(model);

            if (hasText(correlationId)) {
                Message msg = messageService.findMessageByCorrelationId(correlationId,
                        sourceSystem == ExternalSystemEnum.UNDEFINED ? null : sourceSystem);
                if (msg != null) {
                    return "redirect:/web/admin/messages/" + msg.getMsgId();
                } else {
                    model.addAttribute("resultFailed", Boolean.TRUE);

                    return "msg_search";
                }
            }

            model.put("source", sourceSystem);
            model.put("correlation", correlationId);

            return "msg_search";
        }

        private void addExternalSystemsIntoModel(ModelMap model) {
            Map<String, String> systemsMap = new LinkedHashMap<String, String>();
            for (ExternalSystemEnum systemEnum : ExternalSystemEnum.values()) {
                systemsMap.put(systemEnum.name(), systemEnum.name());
            }

            model.addAttribute("systemsMap", systemsMap);
        }

        @RequestMapping(value = "/searchForm", method = RequestMethod.POST)
        public String searchMessage(@RequestParam("sourceSystem") ExternalSystemEnum sourceSystem,
                @RequestParam("correlationId") String correlationId, @ModelAttribute("model") ModelMap model) {

            Message msg = messageService.findMessageByCorrelationId(correlationId,
                    sourceSystem == ExternalSystemEnum.UNDEFINED ? null : sourceSystem);

            if (msg != null) {
                return "redirect:/web/admin/messages/" + msg.getMsgId();
            } else {
                addExternalSystemsIntoModel(model);
                model.addAttribute("resultFailed", Boolean.TRUE);

                return "msg_search";
            }
        }

        @RequestMapping(value = "/messagesByContent", method = { RequestMethod.GET, RequestMethod.POST })
        public String showMessagesByContent(@RequestParam(value = "substring", required = false) String substring,
                @ModelAttribute("model") ModelMap model) {

            if (StringUtils.isNotBlank(substring)) {
                List<Message> messageList = messageService.findMessagesByContent(substring);

                if (!messageList.isEmpty()) {
                    model.addAttribute("messageList", messageList);
                }
                model.put("substring", substring);
            }

            return "msgByContent";
        }

        /**
         * Converts input XML to "nice" XML.
         *
         * @param original the original XML
         * @return pretty XML
         */
        static String prettyPrintXML(String original) {
            try {
                OutputFormat format = OutputFormat.createPrettyPrint();
                Document document = DocumentHelper.parseText(original);
                StringWriter sw = new StringWriter();
                XMLWriter writer = new XMLWriter(sw, format);
                writer.write(document);
                return sw.toString();
            } catch (Exception exc) {
                Log.debug("Error pretty-printing XML: ", exc);
                return original;
            }
        }
    }