source: java/main/src/main/java/com/framsticks/leftovers/FavouritesXMLFactory.java @ 84

package com.framsticks.leftovers;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamWriter;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class FavouritesXMLFactory {

        private final String pathMark = "path";
        private final String nameMark = "name";
        private final String fieldMark = "field";
        private final String typeMark = "type";

        /**
         * Writes favourites nodes and fields list to XML file.
         *
         * @param path
         *            Path of XML file.
         * @param nodes
         *            Collection of user favourites nodes and fields.
         */
        public void writeFavouritesXML(String path, Collection<UserFavourite> nodes) {
                if (nodes.isEmpty()) {
                        return;
                }
                XMLOutputFactory factory = XMLOutputFactory.newInstance();
                BufferedWriter writer = null;
                XMLStreamWriter xmlWriter = null;
                try {
                        File file = new File(path);
                        if (file.exists()) {
                                file.delete();
                        }
                        writer = new BufferedWriter(new FileWriter(file));
                        xmlWriter = factory.createXMLStreamWriter(writer);
                        xmlWriter.writeStartDocument("1.0");
                        xmlWriter.writeStartElement("root");
                        for (UserFavourite node : nodes) {
                                xmlWriter.writeStartElement("item");

                                xmlWriter.writeStartElement(pathMark);
                                xmlWriter.writeCharacters(node.getPath());
                                xmlWriter.writeEndElement();

                                xmlWriter.writeStartElement(nameMark);
                                xmlWriter.writeCharacters(node.getName());
                                xmlWriter.writeEndElement();

                                /*if(node.isFavouriteNode()){
                                        xmlWriter.writeStartElement(typeMark);
                                        xmlWriter.writeCharacters(Integer.toString(node.getNodeType().getId()));
                                        xmlWriter.writeEndElement();
                                }else{ //isFavouriteField() */
                                        xmlWriter.writeStartElement(fieldMark);
                                        xmlWriter.writeCharacters(node.getField());
                                        xmlWriter.writeEndElement();
                                //}

                                xmlWriter.writeEndElement();
                        }

                        xmlWriter.writeEndDocument();
                        xmlWriter.flush();
                } catch (Exception e) {
                } finally {
                        try {
                                xmlWriter.close();
                                writer.close();
                        } catch (Exception e) {
                        }
                }
        }

        /**
         * Reads user favourites nodes and fields from XML file.
         *
         * @param filePath
         *            PAth to XML file.
         * @return LinkedHashMap contains user favourites nodes and fields. Key is
         *         concatenation of path and field getName.
         */
        public LinkedHashMap<String, UserFavourite> readFavouritesXML(String filePath) {
                LinkedHashMap<String, UserFavourite> result = new LinkedHashMap<String, UserFavourite>();

                File file = new File(filePath);
                if (file.exists()) {
                        DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory
                                        .newInstance();
                        try {
                                DocumentBuilder docBuilder = docBuilderFactory
                                                .newDocumentBuilder();
                                Document doc = docBuilder.parse(file);
                                doc.getDocumentElement().normalize();
                                Node root = doc.getFirstChild();
                                NodeList items = root.getChildNodes();
                                UserFavourite userNode;
                                String path, name, field;
                                for (int i = 0; i < items.getLength(); i++) {
                                        Node item = items.item(i);
                                        NodeList itemDetails = item.getChildNodes();
                                        if (itemDetails.getLength() == 3) {
                                                if (itemDetails.item(0).getNodeName().equals(pathMark)
                                                                && itemDetails.item(1).getNodeName().equals(nameMark)
                                                                && (itemDetails.item(2).getNodeName().equals(fieldMark)
                                                                                || itemDetails.item(2).getNodeName().equals(typeMark))) {
                                                        path = itemDetails.item(0).getTextContent();
                                                        name = itemDetails.item(1).getTextContent();
                                                        if (itemDetails.item(2).getNodeName().equals(
                                                                        fieldMark)) {
                                                                field = itemDetails.item(2).getTextContent();
                                                                userNode = new UserFavourite(path, name, field);
                                                                result.put(path+field, userNode);
                                                        }else{
                                                                try {
                                                                        // int nodeTypeId = Integer.parseInt(itemDetails.item(2).getTextContent());
                                                                        userNode = new UserFavourite(path, name, null);
                                                                        result.put(path, userNode);
                                                                } catch (Exception e) {
                                                                }
                                                        }
                                                }
                                        }
                                }
                        } catch (Exception e) {
                        }

                }

                return result;
        }

        /**
         * Writes column configuration to XML file.
         *
         * @param path
         *            Path to XML file.
         * @param groupColumns
         *            Map with column configuration. Key - path to group node. Value -
         *            List of columns getId.
         */
        public void writeColumnConfigurationXML(String path,
                        Map<String, ArrayList<String>> groupColumns) {
                if (groupColumns.isEmpty()) {
                        return;
                }
                XMLOutputFactory factory = XMLOutputFactory.newInstance();
                BufferedWriter writer = null;
                XMLStreamWriter xmlWriter = null;
                try {
                        File file = new File(path);
                        if (file.exists()) {
                                file.delete();
                        }
                        writer = new BufferedWriter(new FileWriter(file));
                        xmlWriter = factory.createXMLStreamWriter(writer);
                        xmlWriter.writeStartDocument("1.0");
                        xmlWriter.writeStartElement("root");

                        Iterator<String> iterator = groupColumns.keySet().iterator();
                        while (iterator.hasNext()) {
                                /*
          Definition of read/write mark.
         */
                                String itemMark = "item";
                                xmlWriter.writeStartElement(itemMark);
                                String itemPath = iterator.next();
                                xmlWriter.writeAttribute(pathMark, itemPath);

                                for (String column : groupColumns.get(itemPath)) {
                                        String columnMark = "column";
                                        xmlWriter.writeStartElement(columnMark);
                                        xmlWriter.writeCharacters(column);
                                        xmlWriter.writeEndElement();
                                }

                                xmlWriter.writeEndElement();
                        }

                        xmlWriter.writeEndDocument();
                        xmlWriter.flush();
                } catch (Exception e) {
                } finally {
                        try {
                                xmlWriter.close();
                                writer.close();
                        } catch (Exception e) {
                        }
                }
        }

        /**
         * Reads column configuration from XML file.
         *
         * @param path
         *            Path to XML file.
         * @return HashMap with configuration. Key - path to group node. Value -
         *         List of columns getId.
         */
        public HashMap<String, ArrayList<String>> readColumnConfigurationXML(
                        String path) {
                HashMap<String, ArrayList<String>> result = new LinkedHashMap<String, ArrayList<String>>();

                File file = new File(path);
                if (file.exists()) {
                        DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory
                                        .newInstance();
                        try {
                                DocumentBuilder docBuilder = docBuilderFactory
                                                .newDocumentBuilder();
                                Document doc = docBuilder.parse(file);
                                doc.getDocumentElement().normalize();
                                Node root = doc.getFirstChild();
                                NodeList items = root.getChildNodes();
                                String itemPath;
                                ArrayList<String> columns;
                                for (int i = 0; i < items.getLength(); i++) {
                                        Node item = items.item(i);
                                        itemPath = item.getAttributes().getNamedItem(pathMark)
                                                        .getNodeValue();
                                        columns = new ArrayList<String>();
                                        NodeList itemDetails = item.getChildNodes();
                                        for (int j = 0; j < itemDetails.getLength(); j++) {
                                                columns.add(itemDetails.item(j).getTextContent());
                                        }
                                        result.put(itemPath, columns);
                                }
                        } catch (Exception e) {
                        }

                }

                return result;
        }
}