source: MDService2/branches/MDService_simple3/src/eu/clarin/cmdi/mdservice/model/Diagnostics.java @ 1540

package eu.clarin.cmdi.mdservice.model;

/**
 * The main model class, carrying users_query
 * able to parse and transform the user-string
 * and execute the query, ie issue appropriate request on the MDRepository
 * getting the url-wording right from MDRepositoryProxy
 *   
 * At the moment just responsible for querying MDRepository
 * perhaps unify approach for other proxies - subtyping this Class  
 */

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class Diagnostics {      

        private ArrayList<Diagnostic> list; 
        private InputStream xmlstream;

        public Diagnostics() {
                list = new ArrayList<Diagnostic>();
        }

        public void Add(int number, String details, String message) {
                list.add(new Diagnostic(number, details, message));
        }
        
        public void Add(int number, String details) {
                list.add(new Diagnostic(number, details));
        }
        public void Add(int number) {
                list.add(new Diagnostic(number));
        }
        
        public void Add(Diagnostic diagnostic){
                list.add(diagnostic);
        }
        
        public Document buildXMLDocument() throws ParserConfigurationException{
                Document doc = null;
                  DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
                  DocumentBuilder docBuilder;
                        docBuilder = docFactory.newDocumentBuilder();
                        //root elements
                          doc = docBuilder.newDocument();
                          Element response = doc.createElement("searchRetrieveResponse");
                          doc.appendChild(response);
                          
                          Element version = doc.createElement("version");
                          version.appendChild(doc.createTextNode("1.2"));
                          response.appendChild(version);
                 
                          Element numberofrecords = doc.createElement("numberOfRecords");
                          numberofrecords.appendChild(doc.createTextNode("0"));
                          response.appendChild(numberofrecords);
                          
                          Element d = doc.createElement("diagnostics");
                          Iterator<Diagnostic> itr = list.iterator();
                                while(itr.hasNext())
                                        d.appendChild(((Diagnostic)itr.next()).buildXMLNode(doc));
                          response.appendChild(d);
                          

                return doc;
        }
        
        //TODO to Utils.java
        /*
        public InputStream buildXMLStream() throws ParserConfigurationException, TransformerConfigurationException, TransformerException, TransformerFactoryConfigurationError, UnsupportedEncodingException{
                if (xmlstream == null){
                        Document doc = buildXMLDocument();
                        DOMSource source = new DOMSource(doc);   
                        StringWriter xmlAsWriter = new StringWriter();   
                        StreamResult result = new StreamResult(xmlAsWriter);    
                        TransformerFactory.newInstance().newTransformer().transform(source, result);
                        xmlstream = new ByteArrayInputStream(xmlAsWriter.toString().getBytes("UTF-8"));
                }
                return xmlstream;
        }
        */
        
        public boolean Accepted(){
                boolean accepted = true;
                
                if (this.list.size() > 0){
                         Iterator<Diagnostic> itr = list.iterator();
                                while(itr.hasNext() && accepted) 
                                {
                                        Diagnostic d = (Diagnostic)itr.next();
                                        if (d.Type().equals(Diagnostic.FATAL)){
                                                accepted = false;       
                                        }
                                }
                        //              accepted = accepted && !((Diagnostic)itr.next()).Type().equals(Diagnostic.FATAL);               
                }
                return accepted;
        }
        
        public boolean Exists(){
                return this.list.size() > 0;
        }
}