source: MDService2/branches/MDService_simple3/src/eu/clarin/cmdi/mdservice/model/Repositories.java @ 1833

package eu.clarin.cmdi.mdservice.model;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;

import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;
import eu.clarin.cmdi.mdservice.internal.MDTransformer;
import eu.clarin.cmdi.mdservice.internal.Utils;
import eu.clarin.cmdi.mdservice.action.FCSAction;
import eu.clarin.cmdi.mdservice.action.WorkspaceAction;
import eu.clarin.cmdi.mdservice.internal.NoStylesheetException;

/**
 
 */



public class Repositories{      

        private static Repositories singleton;
        private static NodeList repositories_nodelist;
        

        public static enum RepositoryType
        {
                MD, SRU, PAZPAR, FCS, FCSRESOURCE, NOVALUE;
                
                public static RepositoryType toRepositoryType(String str)
            {
                try {
                    return valueOf(str.replace(".", "").toUpperCase());
                } 
                catch (Exception ex) {
                    return NOVALUE;
                }
            }   
        }
        
        public NodeList getRepositoriesNodeList(){
                return  repositories_nodelist;
        }
        
        public Repositories() {
                if (repositories_nodelist == null){
                        Init();
                }
        }
        
        
        public static Repositories getRepositories() {
                if (singleton == null) {
                        singleton = new Repositories();
                } 
                return singleton;
        }
        
        public void Init(){
                WorkspaceProfile wsp = WorkspaceProfile.getWorkspaceProfile();
                try {
                        repositories_nodelist = (NodeList ) wsp.getWorkspaceData(
                                        wsp.getXPathExpressionDummy(WorkspaceProfile.XPATH_EXPR_REPOSITORIES, WorkspaceProfile.SERVER),
                                        XPathConstants.NODESET);
                } catch (XPathExpressionException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        
        public Object getDocumentData(Document doc, String xpath_str, QName type) throws XPathExpressionException{
                XPathFactory factory = XPathFactory.newInstance(); 
            XPath xpath = factory.newXPath(); 
            XPathExpression expr;
                        expr = xpath.compile(xpath_str);
                        //expression is evaluated with respect to a certain context node which is doc.
                        Object result = null;
                        try{
                        result = expr.evaluate(doc, type);//XPathConstants.NODESET);
                        } catch(Exception e){
                                
                        }

             return result;
        }
        
        
        
        public String getRepositoryByIndex(int ind){
                String repository_name = null;
                
                if (repositories_nodelist.getLength() > ind){
                        repository_name = repositories_nodelist.item(ind).getChildNodes().item(1).getNodeValue();//("name");
                }
                return repository_name;
                
        }
        
        public String getRepositoryType(String repository_name){
                String typestr = "";
                boolean selected = false;
                
                NodeList chlist = repositories_nodelist.item(0).getChildNodes();
                for(int i=0;i<chlist.getLength();i++){
                        Node node = chlist.item(i);
                        if (node.getNodeName().equals("item")){
                                NodeList list = node.getChildNodes();
                                for(int j=0;j<list.getLength();j++){
                                        if (list.item(j).getNodeName().equals("name") && list.item(j).getTextContent().equals(repository_name)){
                                                selected = true;
                                        }
                                }
                                if (selected){
                                        for(int j=0;j<list.getLength();j++){
                                                if (list.item(j).getNodeName().equals("type")){
                                                        typestr = list.item(j).getTextContent();
                                                }
                                        }
                                        return typestr;
                                }
                        }
                }

        
                return (typestr);

        }
        
        public String getRepositoryPath(String repository_name){
                String uri = "";
                boolean selected = false;
                
                NodeList chlist = repositories_nodelist.item(0).getChildNodes();
                for(int i=0;i<chlist.getLength();i++){
                        Node node = chlist.item(i);
                        if (node.getNodeName().equals("item")){
                                for(int j=0;j<node.getChildNodes().getLength();j++){
                                        if (node.getChildNodes().item(j).getNodeName().equals("name") && node.getChildNodes().item(j).getTextContent().equals(repository_name)){
                                                selected = true;
                                        }
                                }
                                if (selected){
                                        for(int j=0;j<node.getChildNodes().getLength();j++){
                                                if (node.getChildNodes().item(j).getNodeName().equals("uri")){
                                                        uri = node.getChildNodes().item(j).getTextContent();
                                                }
                                        }
                                        return uri;
                                }
                        }
                }
        
                return (uri);

        }
        
        public  Boolean repositoryExists(String repository_name){
                
                
                for(int i=0;i<repositories_nodelist.getLength();i++){
                        if (repositories_nodelist.item(i).getChildNodes().item(1).getNodeValue().equals(repository_name)){
                                return true;
                        }
                }
                
                return false;

        }
        
        public InputStream getXMLStream(String extradata) throws TransformerConfigurationException, TransformerException, TransformerFactoryConfigurationError{
                if (extradata.equals("fcs.resource")){
                        return FCSRepositories.getFCSRepositories().getXMLStream();
                }
                return Utils.document2Stream(repositories_nodelist.item(0));
                
        }

        public InputStream getSRUStream(){
                //if () addFCSRepositories
                
                // convert to SRU
                // SRU nodelist
                // add FCS to nodelist
                // convert to xml
                return null;
                
        }


        
}