Changeset 7830 for mauRepo/newmoon


Ignore:
Timestamp:
24/01/11 16:15:58 (9 years ago)
Author:
mnagni
Message:

Major changes on rules (from code to test). Minor changes on code.

Location:
mauRepo/newmoon
Files:
63 added
2 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • mauRepo/newmoon/pom.xml

    r7816 r7830  
    3535                        <version>1.4.0</version> 
    3636                </dependency> 
     37                <!--  
    3738                <dependency> 
    3839                        <groupId>exist</groupId> 
     
    4041                        <version>1.4.0</version> 
    4142                </dependency> 
    42                 <dependency> 
    43                         <groupId>exist</groupId> 
    44                         <artifactId>xmldb</artifactId> 
    45                         <version>1.4.0</version> 
    46                 </dependency> 
    47                 <dependency> 
     43                                <dependency> 
    4844                        <groupId>exist</groupId> 
    4945                        <artifactId>exist-ngram-module</artifactId> 
     
    5551                        <version>1.4.0</version> 
    5652                </dependency> 
    57                 <dependency> 
     53                                <dependency> 
    5854                        <groupId>org.apache.lucene</groupId> 
    5955                        <artifactId>lucene-regex</artifactId> 
     
    6662                </dependency> 
    6763                <dependency> 
     64                        <groupId>xml-apis</groupId> 
     65                        <artifactId>xml-apis</artifactId> 
     66                        <version>1.3.04</version> 
     67                </dependency> 
     68                <dependency> 
     69                        <groupId>xerces</groupId> 
     70                        <artifactId>xercesImpl</artifactId> 
     71                        <version>2.9.1</version> 
     72                </dependency> 
     73                <dependency> 
     74                        <groupId>xalan</groupId> 
     75                        <artifactId>xalan</artifactId> 
     76                        <version>2.7.1</version> 
     77                </dependency> 
     78                <dependency> 
     79                        <groupId>xalan</groupId> 
     80                        <artifactId>serializer</artifactId> 
     81                        <version>2.7.1</version> 
     82                </dependency>    
     83                <dependency> 
     84                        <groupId>quartz</groupId> 
     85                        <artifactId>quartz</artifactId> 
     86                        <version>1.5.2</version> 
     87                </dependency> 
     88                <dependency> 
     89                        <groupId>com.sun</groupId> 
     90                        <artifactId>xacml</artifactId> 
     91                        <version>1.2</version> 
     92                </dependency> 
     93                <dependency> 
     94                        <groupId>org.apache.xmlrpc</groupId> 
     95                        <artifactId>xmlrpc-common</artifactId> 
     96                        <version>3.0</version> 
     97                </dependency> 
     98                <dependency> 
     99                        <groupId>org.apache.xmlrpc</groupId> 
     100                        <artifactId>xmlrpc-server</artifactId> 
     101                        <version>3.0</version> 
     102                </dependency>                    
     103                 --> 
     104                  
     105                <dependency> 
     106                        <groupId>exist</groupId> 
     107                        <artifactId>xmldb</artifactId> 
     108                        <version>1.4.0</version> 
     109                </dependency> 
     110 
     111 
     112                <dependency> 
    68113                        <groupId>org.apache.xmlrpc</groupId> 
    69114                        <artifactId>xmlrpc-client</artifactId> 
     
    90135                        <version>2.7.7</version> 
    91136                </dependency> 
    92                 <dependency> 
    93                         <groupId>xml-apis</groupId> 
    94                         <artifactId>xml-apis</artifactId> 
    95                         <version>1.3.04</version> 
    96                 </dependency> 
    97                 <dependency> 
    98                         <groupId>xerces</groupId> 
    99                         <artifactId>xercesImpl</artifactId> 
    100                         <version>2.9.1</version> 
    101                 </dependency> 
    102                 <dependency> 
    103                         <groupId>xalan</groupId> 
    104                         <artifactId>xalan</artifactId> 
    105                         <version>2.7.1</version> 
    106                 </dependency> 
    107                 <dependency> 
    108                         <groupId>xalan</groupId> 
    109                         <artifactId>serializer</artifactId> 
    110                         <version>2.7.1</version> 
    111                 </dependency> 
     137 
    112138                <dependency> 
    113139                        <groupId>xml-resolver</groupId> 
     
    145171                        <version>2.2.6</version> 
    146172                </dependency> 
    147                 <dependency> 
    148                         <groupId>quartz</groupId> 
    149                         <artifactId>quartz</artifactId> 
    150                         <version>1.5.2</version> 
    151                 </dependency> 
    152                 <dependency> 
    153                         <groupId>com.sun</groupId> 
    154                         <artifactId>xacml</artifactId> 
    155                         <version>1.2</version> 
    156                 </dependency> 
    157                 <dependency> 
    158                         <groupId>org.apache.xmlrpc</groupId> 
    159                         <artifactId>xmlrpc-common</artifactId> 
    160                         <version>3.0</version> 
    161                 </dependency> 
    162                 <dependency> 
    163                         <groupId>org.apache.xmlrpc</groupId> 
    164                         <artifactId>xmlrpc-server</artifactId> 
    165                         <version>3.0</version> 
    166                 </dependency> 
     173 
    167174 
    168175                <dependency> 
  • mauRepo/newmoon/src/main/java/ndg/services/newmoon/DBManager.java

    r7816 r7830  
    99import org.apache.commons.lang.ArrayUtils; 
    1010import org.apache.commons.lang.StringUtils; 
    11 import org.exist.xmldb.DatabaseInstanceManager; 
    1211import org.exist.xmldb.EXistResource; 
     12import org.exist.xmldb.UserManagementService; 
    1313import org.exist.xmldb.XQueryService; 
    1414import org.slf4j.Logger; 
     
    2626 
    2727        private static boolean running = false; 
    28          
     28 
    2929        private final static DBManager instance = new DBManager(); 
    3030         
    31         public static final String ROOT_COLLECTION_PATH = "xmldb:exist:///db"; 
    3231        private static Collection rootCollection = null; 
    33          
     32 
     33        /** 
     34         * User name for database access. 
     35         */ 
     36        static final String XMLDB_USER = "admin"; 
     37 
     38        /** 
     39         * Password for the XMLDB_USER account. 
     40         */ 
     41        static final String XMLDB_PASSWORD = "newmoon"; 
     42 
    3443        /** 
    3544         * Identification string for the CollectionManagementService XML:DB service. 
     
    5261         */ 
    5362        private static final String XQUERY_SERVICE_SERVICE_VERSION = "1.0"; 
    54          
     63 
    5564        /** 
    5665         * Property name to apply indentation on XML:DB XQueryService result sets. 
     
    5968 
    6069        /** 
     70         * Identification string for the DatabaseInstanceManager XML:DB service. 
     71         */ 
     72        public static final String USER_MGMT_SERVICE_NAME = "UserManagementService"; 
     73 
     74        /** 
     75         * Identification string for the DatabaseInstanceManager XML:DB service 
     76         * version. 
     77         */ 
     78        public static final String USER_MGMT_SERVICE_VERSION = "1.0"; 
     79 
     80        /** 
    6181         * The literal "yes" String value. 
    6282         */ 
     
    6787         */ 
    6888        @SuppressWarnings("unused") 
    69         private static final String NO = "no";   
    70          
     89        private static final String NO = "no"; 
     90 
    7191        /** 
    7292         * Logger for this class. 
    7393         */ 
    7494        private static final Logger LOG = LoggerFactory.getLogger(DBManager.class); 
    75          
     95 
    7696        /** Hides the default constructor */ 
    77         private DBManager(){}; 
    78          
     97        private DBManager() { 
     98        }; 
     99 
    79100        public static DBManager getInstance() { 
    80101                return instance; 
    81102        } 
    82          
     103 
    83104        public static boolean isRunning() { 
    84105                return running; 
    85106        } 
    86          
    87  
     107 
     108        public static String getROOT_COLLECTION_PATH() { 
     109                return "xmldb:exist://localhost:8080/exist/xmlrpc/db"; 
     110        } 
    88111         
    89112        /** 
     
    105128                return newCol; 
    106129        } 
    107          
     130 
    108131        public Resource getResource(Collection collection, String resourceID) throws XMLDBException { 
    109132                collection = collection == null ? getRootCollection() : collection; 
    110133                return collection.getResource(resourceID); 
    111134        } 
    112          
     135 
    113136        public String[] getCollectionResourcesList(String parentCollection, String collectionName) throws XMLDBException { 
    114                 String[] ret = null;  
     137                String[] ret = null; 
    115138                Collection collection = getCollection(parentCollection, collectionName); 
    116139                if (collection != null) { 
    117140                        ret = collection.listResources(); 
    118                 }  
     141                } 
    119142                return ret; 
    120143        } 
    121          
     144 
    122145        public String[] getCollectionResourcesList(Collection collection) throws XMLDBException { 
    123146                collection = collection == null ? getRootCollection() : collection; 
    124147                return collection.listResources(); 
    125148        } 
    126          
     149 
    127150        public Collection getCollection(String parentCollection, String collectionName) throws XMLDBException { 
    128                 Collection parent = getCollection(parentCollection, "admin", ""); 
     151                Collection parent = getCollection(parentCollection, XMLDB_USER, XMLDB_PASSWORD); 
    129152                String[] children = collectionName.split("/"); 
    130153                if (ArrayUtils.isEmpty(children)) { 
    131154                        return parent; 
    132155                } 
    133                 Collection childColl = parent.getChildCollection(children[0]);                           
    134                 for (int index = 1 ; index < children.length ; index++ ) { 
     156                Collection childColl = parent.getChildCollection(children[0]); 
     157                for (int index = 1; index < children.length; index++) { 
    135158                        childColl = childColl.getChildCollection(children[index]); 
    136159                } 
    137160                return childColl; 
    138161        } 
    139          
     162 
    140163        private Collection getCollection(String collectionName, String user, String pwd) throws XMLDBException { 
    141                 collectionName = StringUtils.isBlank(collectionName) ? ROOT_COLLECTION_PATH : collectionName; 
     164                collectionName = StringUtils.isBlank(collectionName) ? getROOT_COLLECTION_PATH() : collectionName; 
    142165                return DatabaseManager.getCollection(collectionName, user, pwd); 
    143166        } 
    144          
     167 
    145168        public void addXMLResource(Collection collection, String resourceId, File file) throws FileNotFoundException, 
    146         XMLDBException, IOException { 
     169                        XMLDBException, IOException { 
    147170                addXMLResource(collection, resourceId, IOUtils.toString(new FileReader(file))); 
    148171        } 
    149          
    150         public void addXMLResource(Collection collection, String resourceId, String resourceXML) throws FileNotFoundException, 
    151         XMLDBException, IOException { 
     172 
     173        public void addXMLResource(Collection collection, String resourceId, String resourceXML) 
     174                        throws FileNotFoundException, XMLDBException, IOException { 
    152175                XMLResource resource = (XMLResource) collection.createResource(resourceId, "XMLResource"); 
    153176                addResource(collection, resource, resourceXML); 
    154         }        
    155          
    156         public void addBinaryResource(Collection collection, String resourceId, File file, String mimeType) throws FileNotFoundException, 
    157         XMLDBException, IOException { 
     177        } 
     178 
     179        public void addBinaryResource(Collection collection, String resourceId, File file, String mimeType) 
     180                        throws FileNotFoundException, XMLDBException, IOException { 
    158181                addBinaryResource(collection, resourceId, IOUtils.toString(new FileReader(file)), mimeType); 
    159182        } 
    160          
    161         public void addBinaryResource(Collection collection, String resourceId, String resourceXML, String mimeType) throws FileNotFoundException, 
    162         XMLDBException, IOException { 
     183 
     184        public void addBinaryResource(Collection collection, String resourceId, String resourceXML, String mimeType) 
     185                        throws FileNotFoundException, XMLDBException, IOException { 
    163186                BinaryResource resource = (BinaryResource) collection.createResource(resourceId, "BinaryResource"); 
    164187                try { 
     
    170193                } 
    171194                addResource(collection, resource, resourceXML); 
    172         }        
    173          
    174         private void addResource(Collection collection, Resource resource, String resourceXML) throws FileNotFoundException, 
    175         XMLDBException, IOException { 
     195        } 
     196 
     197        private void addResource(Collection collection, Resource resource, String resourceXML) 
     198                        throws FileNotFoundException, XMLDBException, IOException { 
    176199                resource.setContent(resourceXML); 
    177200                collection.storeResource(resource); 
    178201                LOG.info("Stored resource " + resource.getId() + " to collection " + collection.getName()); 
    179202        } 
    180          
    181         private Collection getRootCollection() { 
     203 
     204        private Collection getRootCollection() throws XMLDBException { 
     205                if (rootCollection == null) { 
     206                        rootCollection = getCollection(getROOT_COLLECTION_PATH(), XMLDB_USER, XMLDB_PASSWORD); 
     207                } 
    182208                return rootCollection; 
    183209        } 
    184          
    185         private void initEnv() { 
     210 
     211        private void initEnv() throws NewmoonException { 
    186212                System.setProperty("exist.initdb", "true"); 
    187213                String existHome = System.getProperty("exist.home"); 
     214                File existHomeDir = new File(existHome); 
     215                if (!existHomeDir.exists() || (existHomeDir.exists() && !existHomeDir.isDirectory())) { 
     216                        throw new NewmoonException("the System property exist.home does not refer to a directory"); 
     217                } 
    188218                File logs = new File(existHome + "/logs"); 
    189219                logs.mkdir(); 
     
    191221                data.mkdir(); 
    192222        } 
     223 
     224        /** 
     225         * Create and initialise an instance of the database. 
     226         * @throws XMLDBException  
     227         *  
     228         * @throws Exception 
     229         *             if there is an database initialisation error. 
     230         */ 
     231        public void initialiseDBase() throws XMLDBException { 
     232                Collection root = getRootCollection(); 
     233 
     234                // Log in to the database using default admin account and create a 
     235                // new user 
     236                UserManagementService srvUserMgmt = (UserManagementService) root.getService(USER_MGMT_SERVICE_NAME, 
     237                                USER_MGMT_SERVICE_VERSION); 
     238                CollectionManagementService mgtService = (CollectionManagementService)root.getService(COLLECTION_MGMT_SERVICE_NAME, COLLECTION_MGMT_SERVICE_VERSION); 
     239                /* 
     240                User user = srvUserMgmt.getUser(XMLDB_USER); 
     241                if (user != null) 
     242                        srvUserMgmt.removeUser(new User(XMLDB_USER)); 
     243                user = new User(XMLDB_USER, XMLDB_PASSWORD, "dba"); 
     244                user.setHome(XmldbURI.create("/db")); 
     245                try { 
     246                        srvUserMgmt.addUser(user);       
     247                } catch (XMLDBException e) { 
     248                         
     249                } 
     250                */ 
     251                for (NewmoonManager.MODULE_NAME def_coll : NewmoonManager.MODULE_NAME.values()) { 
     252                        mgtService.removeCollection(def_coll.getCollectionName()); 
     253                } 
     254 
     255                for (NewmoonManager.MODULE_NAME def_coll : NewmoonManager.MODULE_NAME.values()) { 
     256                        mgtService.createCollection(def_coll.getCollectionName()); 
     257                } 
     258                LOG.info("Successfully created default collections."); 
     259        } 
    193260         
    194         private void initDB(Collection col) throws XMLDBException { 
    195                 for (NewmoonManager.MODULES_DEF_COLLECTION def_coll : NewmoonManager.MODULES_DEF_COLLECTION.values()) { 
    196                         createCollection(col, def_coll.getCollectionName()); 
    197                 } 
    198         }        
    199          
    200         public void startExist() throws XMLDBException { 
    201                 initEnv(); 
     261        public void startExist() throws XMLDBException, NewmoonException { 
     262                //initEnv(); 
    202263                Database database; 
    203264                try { 
    204265                        Class<?> cl = Class.forName("org.exist.xmldb.DatabaseImpl"); 
    205266                        database = (Database) cl.newInstance(); 
    206                         database.setProperty("create-database", "true"); 
     267                        //database.setProperty("create-database", "true"); 
    207268                        DatabaseManager.registerDatabase(database); 
    208269                        running = true; 
    209270                        // initialize the deafult DB 
    210                         // get a collection 
    211                         rootCollection = getCollection(ROOT_COLLECTION_PATH, "admin", "");; 
    212                         initDB(rootCollection); 
     271                        initialiseDBase(); 
    213272                } catch (ClassNotFoundException e) { 
    214273                        // TODO Auto-generated catch block 
     
    225284        public void stopExist() throws XMLDBException { 
    226285                // shut down the database 
    227                 DatabaseInstanceManager manager = (DatabaseInstanceManager) rootCollection.getService("DatabaseInstanceManager", "1.0"); 
     286                /* 
     287                DatabaseInstanceManager manager = (DatabaseInstanceManager) rootCollection.getService( 
     288                                "DatabaseInstanceManager", "1.0"); 
    228289                manager.shutdown(); 
    229         } 
    230          
     290                */ 
     291        } 
     292 
    231293        public XQueryService getXQueryService() throws XMLDBException { 
    232294                XQueryService service = (XQueryService) getRootCollection().getService(XQUERY_SERVICE_SERVICE_NAME, 
     
    235297                return service; 
    236298        } 
    237          
     299 
    238300        public void mapDBCollection(final Collection collection) throws XMLDBException { 
    239301                final Collection intCollection = collection == null ? getRootCollection() : collection; 
    240                  
     302 
    241303                for (String resource : intCollection.listResources()) { 
    242                         System.out.println("parentCollection:" + intCollection.getParentCollection().getName() + 
    243                                         " - Collection:" +  intCollection.getName() + " - Resource:" + resource); 
     304                        System.out.println("parentCollection:" + intCollection.getParentCollection().getName() + " - Collection:" 
     305                                        + intCollection.getName() + " - Resource:" + resource); 
    244306                } 
    245307                String[] childrenName = intCollection.listChildCollections(); 
     
    248310                } 
    249311        } 
    250          
     312 
    251313        /** 
    252314         * Returns a <code>Collection</code>'s child given its relative path. 
    253          * @param collection the parent Collection. If <code>null</code> the root collection, that is the collection having path  
    254          * {@link #ROOT_COLLECTION_PATH}, is used. 
    255          * @param the path relative to the parent's path 
     315         *  
     316         * @param collection 
     317         *            the parent Collection. If <code>null</code> the root 
     318         *            collection, that is the collection having path 
     319         *            {@link #ROOT_COLLECTION_PATH}, is used. 
     320         * @param the 
     321         *            path relative to the parent's path 
    256322         **/ 
    257323        public Collection getCollectionChild(Collection collection, String childName) throws XMLDBException { 
  • mauRepo/newmoon/src/main/java/ndg/services/newmoon/NewmoonManager.java

    r7818 r7830  
    99import java.io.InputStream; 
    1010import java.io.UnsupportedEncodingException; 
    11 import java.net.URL; 
    1211import java.util.ArrayList; 
    1312import java.util.Collections; 
    14 import java.util.Enumeration; 
    1513import java.util.HashMap; 
    1614import java.util.Iterator; 
     
    6462        public static final String RESULTS_NS = "http://ndg.service.newmoon.conftest-result/1.0"; 
    6563 
    66         /** 
    67          * Name of the default XSLT stylesheet used for formatting the conformance 
    68          * test report. 
    69          */ 
    70         public static final String DEFAULT_REPORT_STYLESHEET = "../resources/conf-test/results-stylesheet.xsl"; 
    71  
    72         public final static String ROOT_COLLECTION_URI = "xmldb:exist:///db"; 
    73  
    74         enum SCHEMA_ENCODING_DEF_COLLECTION { 
    75                 XMI11EA("xmi11ea"); 
     64        enum MODULE_NAME { 
     65                CONFORMANCE_TEST("conformance-test"), SCHEMA_ENCODING("schema-encoding"); 
    7666 
    7767                private final String name; 
    7868 
    79                 private SCHEMA_ENCODING_DEF_COLLECTION(String name) { 
    80                         this.name = name; 
    81                 } 
    82  
    83                 public String getEncodingCollection() { 
    84                         return "schema-encoding/" + this.name; 
    85                 } 
    86  
    87                 public String getEncodingName() { 
    88                         return this.name; 
    89                 } 
    90         } 
    91  
    92         enum MODULES_DEF_COLLECTION { 
    93                 CONFORMANCE_TEST("conformance-test"), SCHEMA_ENCODING("schema-encoding"); 
    94  
    95                 private final String name; 
    96  
    97                 private MODULES_DEF_COLLECTION(String name) { 
     69                private MODULE_NAME(String name) { 
    9870                        this.name = name; 
    9971                } 
     
    12294        } 
    12395 
    124         enum RULES_ROOT_PATH { 
    125                 ISO19136_V3_2_AnxE_XMI_V1_1("rules/conformance-test/ISO19136-V3.2-AnxE_XMI-V1.1"), XMI11EA( 
    126                                 "rules/schema-encoding/xmi11ea"); 
     96        public enum NM_PARAM { 
     97                XMI_DOC("xmi-path"), REPORT_NAME("reportname"), WORKING_DIRECTORY("working-directory"), DEPENDENCY_REGISTER_PATH( 
     98                                "dependency-register-path"), GLM_VERSION("gml-version"), ROOT_COLLECTION_URI("root-collection-uri"), XMLDB_USER( 
     99                                "xmldb-user"), XMLDB_PASSWORD("xmldb-password"), ROOT_COLLECTION_PATH("root-collection-path"), DEFAULT_ENCODE_REPORT_NAME( 
     100                                "EncodeReport"), DEFAULT_CONFORMANCE_REPORT_NAME("ConformanceTestReport"), CONFORMANCE_TEST_DIR( 
     101                                "conformanceDir"), ENCODE_DIR("encodeDir"), RESOURCE_NAME("defaultResourceName"), OUTPUT_DIR( 
     102                                "exportDir"); 
    127103 
    128104                private final String name; 
    129105 
    130                 private RULES_ROOT_PATH(String name) { 
     106                private NM_PARAM(String name) { 
    131107                        this.name = name; 
    132108                } 
    133109 
    134                 public String getRulePath() { 
     110                public String getParamName() { 
    135111                        return this.name; 
    136112                } 
    137  
    138                 public String getRuleName() { 
    139                         return FilenameUtils.getName(getRulePath()); 
    140                 } 
    141         }; 
    142  
    143         /** 
    144          * The outputDir. 
    145          */ 
    146         public static final String OUTPUT_DIR = "/home/users/mnagni/workspace/fullmoon/newmoon/target/classes"; 
     113        } 
     114 
     115        public enum GML_VERSION { 
     116                v3_1("3.1"), v3_2("3.2"); 
     117 
     118                private final String name; 
     119 
     120                private GML_VERSION(String name) { 
     121                        this.name = name; 
     122                } 
     123 
     124                public String getVersion() { 
     125                        return this.name; 
     126                } 
     127        } 
    147128 
    148129        /** 
     
    160141        private static final Map<String, Object> variables = new HashMap<String, Object>(); 
    161142 
    162         private Collection loadQueries(String moduleCollectionName, Collection aCollection, RULES_ROOT_PATH queryDir) 
     143        private Collection loadQueries(String moduleCollectionName, Collection aCollection, String queryDir) 
    163144                        throws XMLDBException, IOException { 
    164145                Collection col = DBManager.getInstance().createCollection(aCollection, moduleCollectionName); 
    165                 addModule(col, queryDir.getRulePath()); 
     146                addModule(col, queryDir); 
    166147                return col; 
    167148        } 
     
    174155        } 
    175156 
    176         private String getAbsolutePath(String path) { 
    177                 URL rs = XMIEncoder.class.getClassLoader().getResource(path); 
    178                 return rs.getPath(); 
    179         } 
    180  
    181157        private List<File> getPathChilds(String path) throws IOException { 
    182                 Enumeration<URL> rs = XMIEncoder.class.getClassLoader().getResources(path); 
    183                 if (!rs.hasMoreElements()) { 
     158                File queries = new File(path); 
     159                if (!queries.exists()) { 
    184160                        return null; 
    185161                } 
    186                 File rootDir = new File(rs.nextElement().getPath()); 
    187                 if (rootDir.isDirectory()) { 
    188                         return (List<File>) FileUtils.listFiles(rootDir, FileFilterUtils.trueFileFilter(), null); 
    189                 } 
    190                 return null; 
     162 
     163                return (List<File>) FileUtils.listFiles(queries, 
     164                                FileFilterUtils.notFileFilter(FileFilterUtils.directoryFileFilter()), null); 
    191165        } 
    192166 
     
    206180        } 
    207181 
    208         protected void setVariables(String reportName, String registryPath, String workingPath, GML_VERSION gmlVersion) { 
    209                 if (variables.size() == 0) { 
    210                         initVariablesMap(); 
    211                 } 
    212                 variables.put("reportname", reportName); 
    213                 variables.put("working-directory", "/" + FilenameUtils.getPathNoEndSeparator(getAbsolutePath(workingPath))); 
    214                 variables.put("dependency-register-path", workingPath + "/" + registryPath); 
    215                 variables.put("gml-version", gmlVersion.getVersion()); 
     182        protected void setVariables(Map<NM_PARAM, String> params) { 
     183                for (NM_PARAM param : params.keySet()) { 
     184                        variables.put(param.getParamName(), params.get(param)); 
     185                } 
     186 
     187                initVariablesMap(); 
     188        } 
     189 
     190        protected void setVariables(NM_PARAM param, String value) { 
     191                variables.put(param.getParamName(), value); 
     192        } 
     193 
     194        protected String getVariables(NM_PARAM param) { 
     195                return (String) variables.get(param.getParamName()); 
    216196        } 
    217197 
    218198        private void initVariablesMap() { 
     199                variables.put(NM_PARAM.OUTPUT_DIR.getParamName(), 
     200                                FilenameUtils.getBaseName(FilenameUtils.getPathNoEndSeparator((String) variables.get(NM_PARAM.XMI_DOC.getParamName()))) + File.separator 
     201                                                + NM_PARAM.OUTPUT_DIR.getParamName()); 
    219202                // -------------------- 
    220                 // Add external XQuery variables. 
    221                 String rootCollectionVarname = "root-collection-uri"; 
    222                 variables.put(rootCollectionVarname, NewmoonManager.ROOT_COLLECTION_URI); 
    223                 String user = "admin"; 
    224                 String userVarname = "xmldb-user"; 
    225                 variables.put(userVarname, user); 
    226                 String pass = ""; 
    227                 String passVarname = "xmldb-password"; 
    228                 variables.put(passVarname, pass); 
    229                  
    230                 String rootCollectionPath = NewmoonManager.ROOT_COLLECTION_URI; 
     203                variables.put(NM_PARAM.ROOT_COLLECTION_URI.getParamName(), DBManager.getROOT_COLLECTION_PATH()); 
     204                String user = DBManager.XMLDB_USER; 
     205                variables.put(NM_PARAM.XMLDB_USER.getParamName(), user); 
     206                String pass = DBManager.XMLDB_PASSWORD; 
     207                variables.put(NM_PARAM.XMLDB_PASSWORD.getParamName(), pass); 
     208 
     209                String rootCollectionPath = DBManager.getROOT_COLLECTION_PATH(); 
    231210                rootCollectionPath = rootCollectionPath.replaceAll("^(.*/exist/xmlrpc)(/[^/]*)$", "$2"); 
    232                 variables.put("root-collection-path", rootCollectionPath); 
     211                variables.put(NM_PARAM.ROOT_COLLECTION_PATH.getParamName(), rootCollectionPath); 
    233212        } 
    234213 
     
    238217         * @throws IOException 
    239218         */ 
    240         protected List<Resource> executePreProcessingScripts(Resource xmiDoc, RULES rules, RULES_ROOT_PATH rulesDir) 
     219        protected List<Resource> executePreProcessingScripts(Resource xmiDoc, RULES rules, String xqueryDir) 
    241220                        throws IOException { 
    242221 
     
    245224 
    246225                if (rules.getRuleName().trim().length() > 0) { 
    247                         queryTests = getPathChilds(rulesDir.getRulePath() + "/" + rules.getRuleName()); 
     226                        queryTests = getPathChilds(xqueryDir + "/" + rules.getRuleName()); 
    248227                } else { 
    249                         queryTests = getPathChilds(rulesDir.getRulePath()); 
     228                        queryTests = getPathChilds(xqueryDir); 
    250229                } 
    251230 
     
    269248                                        results.add(rIter.nextResource()); 
    270249                        } catch (XMLDBException e) { 
    271                                 // TODO Auto-generated catch block 
    272                                 e.printStackTrace(); 
     250                                LOG.info("possible error", e); 
    273251                        } 
    274252                } 
     
    309287        } 
    310288 
    311         public InputStream precessResource(Resource xmiResource, String resourceID, RULES_ROOT_PATH rulesDir, 
    312                         MODULES_DEF_COLLECTION collectionName) { 
     289        public InputStream precessResource(Resource xmiResource, String resourceID, MODULE_NAME collectionName, 
     290                        String xqueryDir, File outputDir) { 
    313291                InputStream ret = null; 
    314292                try { 
    315                         String moduleCollectionName = collectionName.getCollectionName() + "/" + rulesDir.getRuleName(); 
    316                         loadQueries(moduleCollectionName, null, rulesDir); 
     293                        String moduleCollectionName = collectionName.getCollectionName() + "/" + FilenameUtils.getName(xqueryDir); 
     294                        loadQueries(moduleCollectionName, null, xqueryDir); 
    317295 
    318296                        List<Resource> results = new ArrayList<Resource>(); 
    319                         List<Resource> pre = executePreProcessingScripts(xmiResource, RULES.PRE, rulesDir); 
     297                        List<Resource> pre = executePreProcessingScripts(xmiResource, RULES.PRE, xqueryDir); 
    320298                        results.addAll(pre); 
    321299 
    322300                        DBManager.getInstance().mapDBCollection(null); 
    323                         List<Resource> tests = executePreProcessingScripts(xmiResource, RULES.TESTS, rulesDir); 
     301                        List<Resource> tests = executePreProcessingScripts(xmiResource, RULES.TESTS, xqueryDir); 
    324302                        results.addAll(tests); 
    325303 
    326                         List<Resource> post = executePreProcessingScripts(xmiResource, RULES.POST, rulesDir); 
     304                        List<Resource> post = executePreProcessingScripts(xmiResource, RULES.POST, xqueryDir); 
    327305                        results.addAll(post); 
    328  
    329                         ret = reportToFile(resourceID, DEFAULT_REPORT_STYLESHEET, results, (String)variables.get("reportname")); 
     306                         
     307                        //This has to be fixed 
     308                        String defaultReportStylesheet = "http://ndg.services.newmoon/results-stylesheet.xsl"; 
     309                        ret = reportToFile(resourceID, defaultReportStylesheet, results, (String) variables.get(NM_PARAM.REPORT_NAME.getParamName()), outputDir); 
    330310                } catch (XMLDBException e) { 
    331                         // TODO Auto-generated catch block 
    332                         e.printStackTrace(); 
     311                        LOG.info("possible error", e); 
    333312                } catch (IOException e) { 
    334                         // TODO Auto-generated catch block 
    335                         e.printStackTrace(); 
     313                        LOG.info("possible error", e); 
    336314                } 
    337315                return ret; 
     
    347325         * @throws IOException 
    348326         */ 
    349         public InputStream reportToFile(String resourceID, String stylesheet, List<Resource> results, String reportName) 
     327        public InputStream reportToFile(String resourceID, String stylesheet, List<Resource> results, String reportName, File outputDir) 
    350328                        throws XMLDBException, IOException { 
    351329                final String LS = LSEP; 
     
    360338 
    361339                for (Resource result : results) { 
    362                         buffy.append((String) result.getContent()).append(LS); 
     340                        try { 
     341                                buffy.append((String) result.getContent()).append(LS); 
     342                        } catch (Exception e) { 
     343                                LOG.info("possible error", e); 
     344                        } 
    363345                } 
    364346                // Append each result to the root element. 
     
    371353 
    372354                // Write out the raw XML report. 
    373                 String reportPath = OUTPUT_DIR + "/" + reportName + ".xml"; 
    374                 File fXmlReport = new File(reportPath); 
     355                File fXmlReport = new File(outputDir, reportName + ".xml"); 
    375356                FileWriter writer = new FileWriter(fXmlReport); 
    376357                writer.write(buffy.toString()); 
     
    380361        } 
    381362 
    382         public List<String> exportGeneratedResource(String collectionPath) throws NewmoonException, XMLDBException { 
     363        public List<String> exportGeneratedResource(String collectionPath, File exportDir) throws NewmoonException, 
     364                        XMLDBException { 
    383365                List<String> encodeFilePaths = new ArrayList<String>(); 
    384366                Collection collection = DBManager.getInstance().getCollection(null, collectionPath); 
     
    402384                        File tmpFile = null; 
    403385                        try { 
    404                                 tmpFile = File.createTempFile("encoded-", item); 
     386                                tmpFile = new File(exportDir, "encoded-" + item); 
    405387                                writer = new FileWriter(tmpFile); 
    406388                                writer.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); 
     
    409391                                writer.close(); 
    410392                                if (LOG.isInfoEnabled()) { 
    411                                         LOG.info("Saved " + item + " to directory " + OUTPUT_DIR); 
     393                                        LOG.info("Saved " + item + " to directory " + tmpFile.getPath()); 
    412394                                } 
    413395                                encodeFilePaths.add(tmpFile.getAbsolutePath()); 
     
    428410        } 
    429411} 
    430  
    431 enum GML_VERSION { 
    432         v3_1("3.1"), v3_2("3.2"); 
    433  
    434         private final String name; 
    435  
    436         private GML_VERSION(String name) { 
    437                 this.name = name; 
    438         } 
    439  
    440         public String getVersion() { 
    441                 return this.name; 
    442         } 
    443 } 
  • mauRepo/newmoon/src/main/java/ndg/services/newmoon/XMIEncoder.java

    r7818 r7830  
    55import java.io.InputStream; 
    66import java.util.List; 
     7import java.util.Map; 
    78 
    89import javax.xml.bind.JAXBException; 
    910 
    1011import ndg.common.exception.ResourceNotAvailable; 
    11 import ndg.services.newmoon.NewmoonManager.MODULES_DEF_COLLECTION; 
    12 import ndg.services.newmoon.NewmoonManager.RULES_ROOT_PATH; 
     12import ndg.services.newmoon.NewmoonManager.MODULE_NAME; 
     13import ndg.services.newmoon.NewmoonManager.NM_PARAM; 
    1314 
     15import org.apache.commons.io.FilenameUtils; 
    1416import org.apache.commons.lang.text.StrBuilder; 
    1517import org.slf4j.Logger; 
     
    2123public class XMIEncoder { 
    2224 
     25        private String outputdirPath = null;  
     26         
    2327        /** 
    2428         * Logger for this class. 
     
    2630        private static final Logger LOG = LoggerFactory.getLogger(XMIEncoder.class); 
    2731 
    28         private void checkExistStatus() throws XMLDBException { 
     32        private void checkExistStatus() throws XMLDBException, NewmoonException { 
    2933                if (!DBManager.isRunning()) { 
    3034                        DBManager.getInstance().startExist(); 
    3135                } 
    3236        } 
     37         
     38        public String getOutputdirPath() { 
     39                return outputdirPath; 
     40        } 
    3341 
    34         public List<String> doEncode(File xmiDoc, String registryPath, String workingPath, GML_VERSION gmlVersion, String resourceName) throws NewmoonException { 
     42        public void doEncode(Map<NM_PARAM, String> params) 
     43                        throws NewmoonException { 
    3544                try { 
    3645                        checkExistStatus(); 
    37                         return executeEncode(xmiDoc, registryPath, workingPath, gmlVersion, resourceName); 
     46                        executeEncode(params); 
    3847                } catch (XMLDBException e) { 
    3948                        throw new NewmoonException(e); 
     
    4352        } 
    4453 
    45         private List<String> executeEncode(File xmiDoc, String registryPath, String workingPath, GML_VERSION gmlVersion, String resourceName) throws XMLDBException, 
    46                         IOException, NewmoonException { 
    47                 // add a Sample file 
     54        private void executeEncode(Map<NM_PARAM, String> params) 
     55                        throws XMLDBException, IOException, NewmoonException { 
    4856                NewmoonManager nm = new NewmoonManager(); 
    49  
    50                 String schemaEncoding = NewmoonManager.SCHEMA_ENCODING_DEF_COLLECTION.XMI11EA.getEncodingName(); 
     57                nm.setVariables(params); 
     58                 
     59                File xmiDoc = new File(nm.getVariables(NM_PARAM.WORKING_DIRECTORY), nm.getVariables(NM_PARAM.XMI_DOC)); 
     60                 
     61                String resourceName = nm.getVariables(NM_PARAM.RESOURCE_NAME);           
     62                if (resourceName == null) { 
     63                        resourceName = NM_PARAM.RESOURCE_NAME.getParamName(); 
     64                } 
     65                 
     66                String schemaEncoding = FilenameUtils.getName(nm.getVariables(NM_PARAM.ENCODE_DIR)); 
    5167                nm.addXMIResource(null, xmiDoc, resourceName, schemaEncoding); 
    5268                Collection xmiCol = DBManager.getInstance().getCollectionChild(null, schemaEncoding); 
     
    5470                InputStream is = null; 
    5571 
    56                 // Test the XMI File 
    57                 nm.setVariables(NewmoonManager.DEFAULT_REPORT_NAME, registryPath, workingPath, gmlVersion); 
    58                 is = nm.precessResource(xmiResource, resourceName, RULES_ROOT_PATH.ISO19136_V3_2_AnxE_XMI_V1_1, 
    59                                 MODULES_DEF_COLLECTION.CONFORMANCE_TEST); 
     72                //Prepare the outputDir 
     73                File outputDir = new File(nm.getVariables(NM_PARAM.WORKING_DIRECTORY), nm.getVariables(NM_PARAM.OUTPUT_DIR)); 
     74                outputDir.mkdir(); 
     75                outputdirPath = outputDir.getPath(); 
     76                 
     77                // Test the XMI File             
     78                if (!params.containsKey(NM_PARAM.DEFAULT_CONFORMANCE_REPORT_NAME)) { 
     79                        nm.setVariables(NM_PARAM.REPORT_NAME, NM_PARAM.DEFAULT_CONFORMANCE_REPORT_NAME.getParamName()); 
     80                } else { 
     81                        nm.setVariables(NM_PARAM.REPORT_NAME, params.get(NM_PARAM.DEFAULT_CONFORMANCE_REPORT_NAME)); 
     82                } 
     83                 
     84                is = nm.precessResource(xmiResource, resourceName, MODULE_NAME.CONFORMANCE_TEST, 
     85                                nm.getVariables(NM_PARAM.CONFORMANCE_TEST_DIR), outputDir); 
    6086                testReport(is); 
    6187 
    6288                // Encode the XMI File 
    63                 nm.setVariables(NewmoonManager.DEFAULT_ENCODE_REPORT_NAME, registryPath, workingPath, gmlVersion); 
    64                 is = nm.precessResource(xmiResource, resourceName, RULES_ROOT_PATH.XMI11EA, 
    65                                 MODULES_DEF_COLLECTION.SCHEMA_ENCODING); 
    66  
    67                 // Export the generated file 
    68                 return nm.exportGeneratedResource(NewmoonManager.SCHEMA_ENCODING_DEF_COLLECTION.XMI11EA.getEncodingCollection() 
    69                                 + "/working"); 
     89                if (!params.containsKey(NM_PARAM.DEFAULT_ENCODE_REPORT_NAME)) { 
     90                        nm.setVariables(NM_PARAM.REPORT_NAME, NM_PARAM.DEFAULT_ENCODE_REPORT_NAME.getParamName()); 
     91                } else { 
     92                        nm.setVariables(NM_PARAM.REPORT_NAME, params.get(NM_PARAM.DEFAULT_ENCODE_REPORT_NAME)); 
     93                } 
     94                is = nm.precessResource(xmiResource, resourceName, MODULE_NAME.SCHEMA_ENCODING, 
     95                                nm.getVariables(NM_PARAM.ENCODE_DIR), outputDir); 
     96                 
     97                nm.exportGeneratedResource(MODULE_NAME.SCHEMA_ENCODING.getModuleName() + "/" + schemaEncoding + "/working", outputDir); 
    7098        } 
    7199 
     
    93121                                        LOG.error("Error!", e); 
    94122                                } 
    95                                 is = null; 
     123                                //is = null; 
    96124                        } 
    97125                } 
  • mauRepo/newmoon/src/test/java/ndg/services/newmoon/XMIEncoderTest.java

    r7818 r7830  
    11package ndg.services.newmoon; 
    22 
    3 import java.io.File; 
    43import java.net.URL; 
     4import java.util.HashMap; 
    55import java.util.List; 
     6import java.util.Map; 
    67 
     8import ndg.services.newmoon.NewmoonManager.GML_VERSION; 
     9import ndg.services.newmoon.NewmoonManager.NM_PARAM; 
     10 
     11import org.apache.commons.io.FilenameUtils; 
    712import org.junit.After; 
    813import org.junit.Before; 
     
    1823        @After 
    1924        public void shutdown() throws Exception { 
    20                 System.clearProperty("exist.home"); 
    21                 DBManager.getInstance().stopExist(); 
     25                //System.clearProperty("exist.home"); 
     26                //DBManager.getInstance().stopExist(); 
    2227        } 
    2328 
     
    2530        public void encodeXMI() throws NewmoonException { 
    2631                XMIEncoder encoder = new XMIEncoder(); 
    27                 String registryPath = "csml_local_PackageRegister.xml"; 
    28                 String workingPath = "sampleXML"; 
    29                 String sample = "CSML3.xml"; 
     32                String registryPath = "sampleXML/csml_local_PackageRegister.xml"; 
     33                String sample = "sampleXML/CSML3.xml"; 
    3034                GML_VERSION gmlVersion = GML_VERSION.v3_2; 
    3135                String RESOURCE_ID = "CSMLv3"; 
    32                 URL xmiDoc = XMIEncoder.class.getClassLoader().getResource(workingPath + "/" + sample); 
    33                 List<String> encFilePaths = encoder.doEncode(new File(xmiDoc.getPath()), registryPath, workingPath, gmlVersion, RESOURCE_ID); 
    34                 for (String filePath : encFilePaths) { 
    35                         System.out.println(filePath); 
    36                 } 
     36                String workingPath = XMIEncoder.class.getClassLoader().getResource(".").getPath(); 
     37                URL testDir = XMIEncoder.class.getClassLoader().getResource("rules/conformance-test/ISO19136-V3.2-AnxE_XMI-V1.1"); 
     38                URL endodeDir = XMIEncoder.class.getClassLoader().getResource("rules/schema-encoding/xmi11ea"); 
     39                 
     40                Map<NM_PARAM, String> params = new HashMap<NewmoonManager.NM_PARAM, String>(); 
     41                params.put(NM_PARAM.REPORT_NAME, NewmoonManager.DEFAULT_REPORT_NAME); 
     42                params.put(NM_PARAM.WORKING_DIRECTORY, "/" + FilenameUtils.getPathNoEndSeparator(workingPath)); 
     43                params.put(NM_PARAM.DEPENDENCY_REGISTER_PATH, registryPath); 
     44                params.put(NM_PARAM.GLM_VERSION, gmlVersion.getVersion()); 
     45                params.put(NM_PARAM.CONFORMANCE_TEST_DIR, testDir.getPath()); 
     46                params.put(NM_PARAM.ENCODE_DIR, endodeDir.getPath()); 
     47                params.put(NM_PARAM.RESOURCE_NAME, RESOURCE_ID); 
     48                params.put(NM_PARAM.XMI_DOC, sample);                            
     49                encoder.doEncode(params); 
     50                System.out.println(encoder.getOutputdirPath()); 
    3751        } 
    3852} 
Note: See TracChangeset for help on using the changeset viewer.