build.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE project [
<!ENTITY buildJava SYSTEM "./build_java.xml">
<!ENTITY buildDB SYSTEM "./build_db.xml">
]>

<project name="VO-URP-builder - GitHub" default="about" basedir=".">

	<description>
    This build file can be considered as the transformer tool for any Data Model in XMI format to other documents : 
    - XML schemas (xsd)
    - documentation (html)
    - java formatted code (JPA / JAXB compliant) + javadoc
    - DDL script (microsoft sql server / postgresql databases / oracle soon ?)
    - TAP VOTABLEs
     
    Authors : bourges.laurent@gmail.com, gerard.lemson@mpe.mpg.de
    
    This Version : 01 october 2011
  	</description>




	<!-- set global properties for this build -->
	<property name="vo-urp.title" value="VO-URP"/>
	<property name="vo-urp.vendor" value="Gerard Lemson, Laurent Bourges"/>
	<property name="vo-urp.version" value="0.x"/>

	<tstamp>
		<format property="build.date.extension" pattern="yyyyMMddHHmmss" />
	</tstamp>

	<!--
      Get build properties (general).
	  Should only contain the location of the directory where input properties and data model can be found.
	-->
	<property file="build.properties"/>

	<fail unless="input"                  message="Must define property 'input' in build.properties (indicating project directory) !"/>
<echo>input = ${input}</echo>
	<property file="${input}/project.properties" />

	<!-- do not change -->
	<property name="xmi2intermediate" value="xmi2intermediate.xsl"/>
  <property name="model_package" value="org.ivoa.dm.model"/>
	<property name="build.src.file" value="vo-urp-src.jar"/>

	<!-- read pipeline configuration properties -->
	<fail unless="project.name"           message="Must define property 'project.name' in ${props.file} (name of this project) !" />
	<fail unless="project.version"        message="Must define property 'project.version' in ${input}/project.properties !" />
	<fail unless="source"                 message="Must define property 'source' in ${input}/project.properties (the source data model file as xmi 2.x) !" />
	<fail unless="xmi2intermediate"       message="Must define property 'xmi2intermediate' in ${input}/project.properties (the basic xmi2intermediate xsl file) !"/>
	<fail unless="root_package"           message="Must define property 'root_package' in ${input}/project.properties (the root package) !" />
	<fail unless="targetnamespace_root"   message="Must define property 'targetnamespace_root' in ${input}/project.properties (the target namespace root) !" />
	<fail unless="schemalocation_root"    message="Must define property 'schemalocation_root' in ${input}/project.properties (the schema location root) !" />

	<!-- convert target switches to ant conditionnal properties -->
	<fail unless="target.db.active"       message="Must define property 'target.db.active' in ${input}/project.properties (true if db targets should run) !" />
	<fail unless="target.run.active"      message="Must define property 'target.run.active' in ${input}/project.properties (true if run target should run) !" />
	<fail unless="target.weaving.active"  message="Must define property 'target.weaving.active' in ${input}/project.properties (true if weaving target should run) !" />

	<condition property="has.test">
		<isset property="sources.test"/>
	</condition>
	<condition property="target.db.do">
		<equals arg1="${target.db.active}" arg2="true" trim="true" />
	</condition>
	<condition property="target.db.backup.do">
		<equals arg1="${target.db.backup.active}" arg2="true" trim="true" />
	</condition>
	<condition property="target.run.do">
		<and>
			<equals arg1="${target.run.active}" arg2="true" trim="true" />
			<isset property="sources.test"/>
		</and>
	</condition>
	<condition property="target.weaving.do">
		<equals arg1="${target.weaving.active}" arg2="true" trim="true" />
	</condition>


	<!-- output files -->
	<property name="source_checked" value="${project.name}_CHECK.xml" />
	<property name="source_filtered" value="${project.name}_FILTER.xml" />
	<!--
	<property name="source_intermediate" value="${project.name}_INTERMEDIATE.xml" />
	-->
	<property name="source_intermediate" value="${project.name}.vo-urp.xml" />

	<!-- vo-urp paths -->
	<property name="root" location="." />
	<property name="res" location="./res" />
	<property name="templates" location="./templates" />
	<property name="libs" location="./libs" />
	<property name="sources" location="./src" />
	<property name="classes" location="./classes" />


	<!-- define and instantiate output directories -->
	<property name="output" location="${input}/output"/>
	<property name="build" location="${input}/build"/>
	<property name="dist" location="${input}/dist"/>
	<property name="properties" location="${input}/properties"/>
	<property name="dist.lib" location="${dist}/lib" />
	<property name="javadoc" location="${dist}/doc" />
	<property name="outputHTML" location="${output}/html"/>
	<property name="outputJava" location="${output}/java"/>
	<property name="sources.gen" location="${outputJava}" />
	<property name="output.xsd" location="${output}/schema" />
	<property name="build" location="./build" />
	<property name="build.src" location="${build}/src" />
	<property name="build.gen" location="${build}/gen" />
	<property name="build.weaving" location="${build}/weaving" />
	<property name="build.test" location="${build}/test" />
	<property name="build.xsd" location="${build}/xsd" />
	<property name="test" location="${input}/${sources.test}"/>

	<!-- preamble file, may be set in project.properties -->
	<property name="html.preamble.file" value="output/html/preamble.html"/>
	<property name="html.preamble" location="${input}/${html.preamble.file}"/>

	<property name="webapp.member.role" value="${project.name}-member"/>
	<property name="webapp.admin.role" value="${project.name}-admin"/>



	<!-- graphviz properties -->
	<available property="graphviz.check" file="${graphviz.path}" />

	<property name="graphviz.png" value="${project.name}.png"/>
	<property name="graphviz.map" value="${project.name}.cmap"/>
	<!-- <property name="graphviz.map" value="${project.name}.cmap"/> -->
	<property name="graphviz.map.placeholder" value="___GRAPHVIZ_MAP___"/>



	<!-- JDBC drivers -->
	<fileset id="jdbcfiles" dir="${libs}/jdbc">
		<!-- postgres 8.x driver -->
		<include name="postgresql-8.3-603.jdbc3.jar"/>
		<!-- sql server 2005 driver -->
		<include name="sqljdbc-2005-1.2.jar"/>
	</fileset>

	<!-- class path for JDBC drivers -->
	<path id="jdbc-drivers.class.path">
		<fileset refid="jdbcfiles"/>
	</path>

	<!-- adds README.txt to default excludes -->
	<defaultexcludes echo="false" add="**/README.txt" />




	<!-- presets -->

	<!-- Performs an XSL translation of an XML file using the Saxon processor. -->
	<presetdef name="xslt2">
		<!-- The processor=SaxonLiaison setting causes our custom XSLTLiaison class to be used. -->
		<!-- This works around bug #41314: http://issues.apache.org/bugzilla/show_bug.cgi?id=41314 -->
		<xslt force="true" classpath="${libs}/saxon9.jar:${libs}/anthack/libs/ant-trax.jar:${libs}/anthack/" processor="SaxonLiaison">
			<outputproperty name="{http://saxon.sf.net/}indent-spaces" value="2" />
		</xslt>

	</presetdef>

	<taskdef resource="net/sf/antcontrib/antlib.xml"/>

	<!-- targets -->

	<!-- target init : timestamp -->
	<target name="init">

		<!-- define and instantiate output directories -->
		<mkdir dir="${output}"/>
		<mkdir dir="${build}"/>
		<mkdir dir="${dist}"/>
		<mkdir dir="${properties}"/>
		<mkdir dir="${dist.lib}"/>
		<mkdir dir="${javadoc}"/>
		<mkdir dir="${outputJava}"/>
		<mkdir dir="${build}"/>
		<mkdir dir="${build.src}"/>
		<mkdir dir="${build.gen}"/>
		<mkdir dir="${build.weaving}"/>

		<mkdir dir="${libs}/jalopy/bin"/>

		<tstamp>
			<format property="build.date" pattern="dd/MM/yyyy HH:mm:ss" />
		</tstamp>

		<echo>-------------------------------------------------------------------------------</echo>
		<echo>  ${project.vendor} </echo>
		<echo>  ${project.title} - ${project.version} </echo>
		<echo>-------------------------------------------------------------------------------</echo>
		<echo> Build File </echo>
		<echo>-------------------------------------------------------------------------------</echo>
		<echo> Contacts    : ${project.authors}  </echo>
		<echo> Build date  : ${build.date} </echo>
		<echo>-------------------------------------------------------------------------------</echo>
		<echo> project name     : ${project.name} </echo>
		<echo> source           : ${source} </echo>
		<echo> root package     : ${root_package} </echo>
		<echo> model package    : ${model_package} </echo>
		<echo> schema location  : ${schemalocation_root} </echo>
		<echo> target namespace : ${targetnamespace_root} </echo>
		<echo>-------------------------------------------------------------------------------</echo>

		<echo> target.run.active    : ${target.run.active} </echo>
		<echo>-------------------------------------------------------------------------------</echo>


		<!-- up to date checks -->

		<!-- checks if input & xslt are modified compare to intermediate document -->
		<uptodate property="intermediate.notRequired">
			<srcfiles dir="${input}" includes="${source}" />
			<srcfiles dir="${res}" includes="xmiCheck.xsl" />
			<srcfiles dir="${res}" includes="xmiFilter.xsl" />
			<srcfiles dir="${res}" includes="${xmi2intermediate}" />
			<mapper type="merge" to="${output}/${source_intermediate}" />
		</uptodate>

		<!-- checks if intermediate & xslt documents are modified compare to xsd-gen.log -->
		<uptodate property="xsd.notRequired">
			<srcfiles dir="${output}" includes="${source_intermediate}" />
			<srcfiles dir="${res}" includes="intermediate2xsd.xsl" />
			<srcfiles dir="${res}" includes="common.xsl" />
			<srcfiles dir="${res}" includes="common-xsd.xsl" />
			<mapper type="merge" to="${output}/schema/xsd-gen.log" />
		</uptodate>

		<!-- checks if intermediate & xslt documents are modified compare to ddl-gen.log -->
		<uptodate property="ddl.notRequired">
			<srcfiles dir="${output}" includes="${source_intermediate}" />
			<srcfiles dir="${res}" includes="intermediate2ddl.xsl" />
			<srcfiles dir="${res}" includes="common-ddl.xsl" />
			<srcfiles dir="${res}" includes="utype.xsl" />
			<mapper type="merge" to="${output}/ddl/ddl-gen.log" />
		</uptodate>

		<!-- checks if intermediate & xslt documents are modified compare to tap-gen.log -->
		<uptodate property="tap.notRequired">
			<srcfiles dir="${output}" includes="${source_intermediate}" />
			<srcfiles dir="${res}" includes="intermediate2tap.xsl" />
			<srcfiles dir="${res}" includes="intermediate2ddl.xsl" />
			<srcfiles dir="${res}" includes="common-ddl.xsl" />
			<srcfiles dir="${res}" includes="utype.xsl" />
			<mapper type="merge" to="${output}/tap/tap-gen.log" />
		</uptodate>

		<!-- checks if intermediate & xslt documents are modified compare to  java-gen.log -->
		<uptodate property="java.notRequired">
			<srcfiles dir="${output}" includes="${source_intermediate}" />
			<srcfiles dir="${res}" includes="intermediate2java.xsl" />
			<srcfiles dir="${res}" includes="common.xsl" />
			<srcfiles dir="${res}" includes="common-ddl.xsl" />
			<srcfiles dir="${res}" includes="common-xsd.xsl" />
			<srcfiles dir="${res}" includes="jpa.xsl" />
			<srcfiles dir="${res}" includes="jaxb.xsl" />
			<srcfiles dir="${templates}" includes="persistence-template.xml" />

			<!-- check if src/ java code has changed -->
			<srcfiles dir="${sources}" includes="**/*" />

			<srcfiles dir="${output}" includes="${source_intermediate}" />
			<mapper type="merge" to="${sources.gen}/java-gen.log" />
		</uptodate>
	</target>




	<!-- target about : -->
	<target name="about" depends="init" description="show information for public targets">
		<echo>available ant targets : </echo>
		<echo>-------------------------------------------------------------------------------</echo>
		<echo>  - cleanAll      : CLEANS outputs </echo>
		<echo>  - makeAll       : make all transformations (uml -> metaModel -> others) </echo>
		<echo>  - forceMakeAll  : CLEANS outputs and then make all transformations (makeAll) </echo>
		<echo>-------------------------------------------------------------------------------</echo>
	</target>




	<!-- main target : generates all documents -->
	<target name="makeAll" depends="init, process" description="make all transformations">
		<echo>makeAll : done.</echo>
	</target>




	<!-- main target : force to generate all documents -->
	<target name="forceMakeAll"  depends="init, cleanOutput, cleanJava" description="CLEANS outputs and make all transformations (forced)">
		<ant target="makeAll" inheritAll="false" />
		<echo>forceMakeAll : done.</echo>
	</target>




	<!-- main target : force to clean all generated products -->
	<target name="cleanAll"  depends="init, cleanOutput, cleanJava" description="CLEANS outputs">
		<echo>cleanAll : done.</echo>
	</target>




	<!-- target cleanOutput : clean all output files (ddl, java, schema ...) -->
	<target name="cleanOutput">

		<echo>cleaning directory : ${output} ...</echo>

		<!-- do not remove directories to have respect for .svn directories -->
		<delete includeemptydirs="false" verbose="true">
			<fileset dir="${output}">
				<exclude name="java/**/*" />
			</fileset>
		</delete>

		<echo>cleaned directory : ${output} : done.</echo>
	</target>




	<!-- target cleanOutput : clean java output files -->
	<target name="cleanJavaOutput">

		<echo>cleaning directory : ${outputJava} ...</echo>

		<!-- do not remove directories to have respect for .svn directories -->
		<delete includeemptydirs="false" verbose="true">
			<fileset dir="${outputJava}" />
		</delete>

		<echo>cleaned directory : ${outputJava} : done.</echo>
	</target>


	<!-- create and compile Java code. Useful for quick testing. -->
	<target name="runJava">
		<property name="source" value="${source}" />
		<property name="source_filtered" value="${source_filtered}" />

		<ant target="processXMI2Intermediate" inheritAll="false">
			<propertyset>
				<propertyref prefix="source" />
				<propertyref prefix="source_filtered" />
			</propertyset>
		</ant>

		<ant target="processIntermediate2Java" inheritAll="false">
			<propertyset>
				<propertyref prefix="source" />
				<propertyref prefix="source_filtered" />
			</propertyset>
		</ant>
		
		<!-- build web app -->
		<ant target="buildWeb" />

  </target>

	<!-- target process : xslt pipeline + DB + test cases -->
	<target name="process">
		<property name="source" value="${source}" />
		<property name="source_filtered" value="${source_filtered}" />

		<ant target="processXMI2Intermediate" inheritAll="false">
			<propertyset>
				<propertyref prefix="source" />
				<propertyref prefix="source_filtered" />
			</propertyset>
		</ant>

		<ant target="processIntermediate2XSD" inheritAll="false">
			<propertyset>
				<propertyref prefix="source" />
				<propertyref prefix="source_filtered" />
			</propertyset>
		</ant>

		<ant target="processIntermediate2DDL" inheritAll="false">
			<propertyset>
				<propertyref prefix="source" />
				<propertyref prefix="source_filtered" />
			</propertyset>
		</ant>

		<ant target="processIntermediate2TAP" inheritAll="false">
			<propertyset>
				<propertyref prefix="source" />
				<propertyref prefix="source_filtered" />
			</propertyset>
		</ant>

		<ant target="processIntermediate2Java" inheritAll="false">
			<propertyset>
				<propertyref prefix="source" />
				<propertyref prefix="source_filtered" />
			</propertyset>
		</ant>


		<!-- update DB if needed -->
		<if>
			<equals arg1="${target.db.active}" arg2="true"/>
			<then>
				<ant target="DB-setup" />
			</then>
		</if>

		<!-- build web app -->
		<ant target="buildWeb" />

		<!-- run test cases if needed -->
		<ant target="run" />
	</target>


	<target name="DB-setup" depends="DB-retrieveDDLs,DB-initFor" description="Setup database, perform migration if requested">

		<!-- copy files from ddl-s to backup, in case there are no files in the DB yet. So at least some 
 		files will be there when drop is called. That may cause problems -->
		<if>
			<equals arg1="${target.db.backup.active}" arg2="true"/>
			<then>
				<echo>Perform backup</echo>
				<doSqlTarget autocommit="true" onerror="continue" src="${ddl.directory}/backup/backupTables.sql" />
				<ant target="DB-clean"/>
				<ant target="DB-create"/>
				<doSqlTarget autocommit="false" onerror="continue" errorproperty="migrateerror" src="${ddl.directory}/backup/migrateTables.sql" />
				<if>
					<isset property="migrateerror"/>
					<then>
						<echo>!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!</echo>
						<echo>Error while migrating: fix migration script and run by hand</echo>
						<echo>!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!</echo>
					</then>
					<else>
						<doSqlTarget autocommit="true" onerror="continue" src="${ddl.directory}/backup/dropBackupTables.sql" />
					</else>
				</if>
			</then>
			<else>
				<echo>No backup required</echo>
				<ant target="DB-clean"/>
				<ant target="DB-create"/>
			</else>
		</if>
	</target>

	<!-- target buildJava : makes both java libraries and the vo-urp browser web application -->
	<target name="buildJava" description="build both java libraries and the web application">
		<ant target="makeOutput" />
		<ant target="buildWeb" />
	</target>




	<!-- target buildWeb : makes the vo-urp browser web application -->
	<target name="buildWeb" description="build web application only">
		<ant antfile="webapp/vo-urp-browser/build.xml" target="deployTomcat" inheritAll="false">
			<property name="input" location="${input}"/>
			<property name="schemalocation_root" value="${schemalocation_root}"/>
			<property name="webapp.member.role" value="${webapp.member.role}"/>
			<property name="webapp.admin.role" value="${webapp.admin.role}"/>
			<property name="build.date.extension" value="${build.date.extension}"/>
		</ant>
	</target>




	<!-- target processXMI2Intermediate : check the XMI model, filter it and generate the intermediate model -->
	<target name="processXMI2Intermediate" unless="intermediate.notRequired">
		<ant target="checkSource">
			<property name="source_checked" value="${source_checked}" />
		</ant>
		<ant target="filterSource" />
		<ant target="run_xmi2intermediate" />
	</target>




	<!-- target processIntermediate2XSD : generates XML Schemas, XML samples and HTML documentation -->
	<target name="processIntermediate2XSD" unless="xsd.notRequired">
		<ant target="run_intermediate2xsd" />
		<ant target="run_intermediate2html" />
<!--		
		<ant target="run_intermediate2xml" />
-->
	</target>




	<!-- target processIntermediate2DDL : generates DDL scripts -->
	<target name="processIntermediate2DDL" unless="ddl.notRequired">
		<ant target="run_intermediate2ddl" />
	</target>




	<!-- target processIntermediate2TAP : generates TAP model -->
	<target name="processIntermediate2TAP" unless="tap.notRequired">
		<ant target="run_intermediate2tap" />
	</target>




	<!-- target processIntermediate2Java : clean java outputs, generates java code from intermediate model and compiles java codes -->
	<target name="processIntermediate2Java" unless="java.notRequired">
		<ant target="cleanJavaOutput" />
		<ant target="run_intermediate2java" />
		<ant target="makeOutput" />
	</target>




	<!-- generic targets -->

	<!-- target checkSource : check xmi well formed tags in source document -->
	<target name="checkSource">
		<echo>checkSource : starting checks on file ${input}/${source}</echo>

		<xslt2 in="${input}/${source}" out="${output}/${source_checked}" style="${res}/xmiCheck.xsl" />

		<echo>checkSource : done.</echo>
	</target>




	<!-- target filterSource : remove all xmi:Extension tags in source document -->
	<target name="filterSource">
		<echo>filterSource : starting filter on file ${input}/${source}</echo>

		<xslt2 in="${input}/${source}" out="${output}/${source_filtered}" style="${res}/xmiFilter.xsl" />

		<echo>filterSource : done.</echo>
	</target>



	<target name="generateAll">
		<property name="source" value="${source}" />
		<property name="source_filtered" value="${source_filtered}" />

		<ant target="run_xmi2intermediate" inheritAll="true"/>

		<ant target="run_intermediate2ddl" inheritAll="true"/>
		<ant target="run_intermediate2gvd" inheritAll="true"/>
		<ant target="run_intermediate2html" inheritAll="true"/>
		<ant target="run_intermediate2java" inheritAll="true"/>
		<!--		<ant target="run_intermediate2rdf" inheritAll="true"/>  -->
		<ant target="run_intermediate2tap" inheritAll="true"/>
		<ant target="run_intermediate2xml" inheritAll="true"/>
		<ant target="run_intermediate2xsd" inheritAll="true"/>

	</target>


	<!-- target run_xmi2intermediate : transform the source model (xmi) to the intermediate model -->
	<target name="run_xmi2intermediate">
		<ant target="xmi2intermediate">
			<property name="source" value="${input}/${source}" />
			<property name="source_filtered" value="${source_intermediate}" />
		</ant>
	</target>
	<!-- +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
                                  VO-URP generation
     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	-->
	<target name="run_vo-urp">
		<!-- run all vo-urp targets -->
		<property name="source" value="${source}" />
		<property name="source_filtered" value="${source_filtered}" />

		<ant target="run_xmi2vo-urp" inheritAll="true"/>
		<ant target="run_vo-urp2html" inheritAll="true"/>

	</target>

	<!-- target run_xmi2vo-urp : transform the source model (xmi) to the vo-urp model 
	then generate the utype-s-->
	<target name="run_xmi2vo-urp">
		<fail unless="xmi2vo-urp" message="Must define property 'xmi2vo-urp' in ${input}/project.properties (the basic xmi2vo-urp translaytion script) !"/>
		<xslt2 in="${input}/${source}" out="${input}/TEMP_${source_intermediate}" style="${res}/${xmi2vo-urp}">
			<param name="root_package" expression="${root_package}" />
			<param name="model_package" expression="${model_package}" />
		</xslt2>

		<xslt2 in="${input}/TEMP_${source_intermediate}"
			  out="${input}/${source_intermediate}" 
			style="${res}/generate-utypes4vo-urp.xsl">
		</xslt2>

		<delete file="${input}/TEMP_${source_intermediate}"/>
	</target>

	<target name="run_vo-urp2modelproxy">
		<echo>run_vo-urp2html : starting generate HTML from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${input}/${source_intermediate}" out="${input}/${project.name}.modelproxy.xml"
			style="${res}/vo-urp2modelproxy.xsl">
		</xslt2>
	</target>

	<target name="run_vo-urp2html" depends="run_vo-urp2gvd">
		<echo>run_vo-urp2html : starting generate HTML from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${input}/${source_intermediate}" out="${input}/${project.name}.html"
			style="${res}/vo-urp2html.xsl">
			<param name="project_name" expression="${project.name}"/>
			<param name="graphviz_png" if="graphviz.path" expression="${graphviz.png}"/>
			<param name="graphviz_map" if="graphviz.path" expression="${graphviz.map.placeholder}"/>
			<param name="preamble" expression="${html.preamble}"/>
		</xslt2>
		<!--
		<copy todir="${input}">
            <fileset dir="css">
                <include name="*.css" />
            </fileset>
        </copy>
-->
		<ant target="postGenerateHTML_vo-urp" />

		<echo>run_vo-urp2html : done.</echo>
	</target>

	<!-- target run_intermediate2gvd : generates Object Graphs (graphviz tool) from intermediate model -->
	<!-- note : this target not included in the standard pipeline : run it manually -->
	<target name="run_vo-urp2gvd" if="graphviz.path">
		<echo>run_vo-urp2gvd : starting generate GraphViz from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${input}/${source_intermediate}" out="${input}/${project.name}.gvd" style="${res}/vo-urp2gvd.xsl" />

		<exec executable="${graphviz.path}" dir="${input}" >
			<arg value="-Tcmapx" />
			<arg value="-o${graphviz.map}" />
			<arg value="-Tpng"/>
			<arg value="-o${graphviz.png}"/>
			<arg value="${project.name}.gvd"/>
		</exec>
		<echo>run_vo-urp2gvd : done.</echo>

	</target>

	<!-- +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->

	<!-- target xmi2intermediate : GenTool preprocessor generating according to ivoaDMMetamodel.xsd -->
	<target name="xmi2intermediate">
		<echo>xmi2intermediate : starting generate intermediate model from file ${output}/${source}</echo>

		<xslt2 in="${source}" out="${output}/${source_filtered}" style="${res}/${xmi2intermediate}">
			<param name="root_package" expression="${root_package}" />
			<param name="model_package" expression="${model_package}" />
			<param name="modelversion" expression="${project.version}"/>
		</xslt2>

		<echo>xmi2intermediate : done.</echo>
	</target>




	<!-- target run_intermediate2xsd : generates XML schemas from intermediate model -->
	<target name="run_intermediate2xsd">
		<echo>run_intermediate2xsd : starting generate XSD files from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${output}/${source_intermediate}" out="${output.xsd}/xsd-gen.log" style="${res}/intermediate2xsd.xsl">
			<param name="targetnamespace_root" expression="${targetnamespace_root}" />
			<param name="schemalocation_root" expression="${schemalocation_root}" />
			<param name="generateAppinfo" expression="true" />
			<param name="project_name" expression="${project.name}" />
		</xslt2>

		<copy verbose="true" todir="${output}/schema" preservelastmodified="true">
			<fileset file="./xsd/base.xsd" />
		</copy>

		<echo>run_intermediate2xsd : done.</echo>
	</target>




	<!-- generate template XML docs for each of the root elements -->
	<target name="run_intermediate2xml">
		<echo>run_intermediate2xml : starting generate XML sample documents from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/xml-samples/xml-gen.log" style="${res}/intermediate2xml.xsl">
			<param name="targetnamespace_root" expression="${targetnamespace_root}" />
		</xslt2>

		<echo>run_intermediate2xml : done.</echo>
	</target>




	<!-- target run_readSKOS : generates SKOS vocabularie and trasforms them -->
	<!-- note : this target not included in the standard pipeline : run it manually -->
	<target name="run_readSKOS">
		<echo>run_intermediateSKOS2simpleSKOS : starting generate Simple SKOS files from SKOS URIs in ${output}/${source_intermediate}</echo>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/skos/skos-gen.log" style="${res}/readSKOS.xsl"/>

		<echo>run_intermediate2xsd : done.</echo>
	</target>




	<!-- target run_intermediate2html : generates HTML Documentation from intermediate model -->
	<target name="run_intermediate2html" depends="run_intermediate2gvd">
		<echo>run_intermediate2html : starting generate HTML from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/html/${project.name}.html"
			style="${res}/intermediate2html_v2.xsl">
			<param name="project_name" expression="${project.name}"/>
			<param name="graphviz_png" if="graphviz.path" expression="${graphviz.png}"/>
			<param name="graphviz_map" if="graphviz.path" expression="${graphviz.map.placeholder}"/>
			<param name="preamble" expression="${html.preamble}"/>
		</xslt2>
		<copy todir="${output}/html">
			<fileset dir="css">
				<include name="*.css" />
			</fileset>
		</copy>

		<ant target="postGenerateHTML" />

		<echo>run_intermediate2html : done.</echo>
	</target>

	<target name="postGenerateHTML"  if="graphviz.path" >
		<loadfile property="map" srcfile="${outputHTML}/${graphviz.map}"/>

		<replace file="${outputHTML}/${project.name}.html" token="${graphviz.map.placeholder}" value="${map}"/>
	</target>

	<target name="postGenerateHTML_vo-urp"  if="graphviz.path" >
		<loadfile property="map" srcfile="${input}/${graphviz.map}"/>

		<replace file="${input}/${project.name}.html" token="${graphviz.map.placeholder}" value="${map}"/>
	</target>

	<!-- target run_intermediate2rdf : generates a RDF instance from intermediate model -->
	<target name="run_intermediate2rdf" >
		<echo>run_intermediate2rdf : starting generate RDF from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/rdf/{project.name}.rdf" style="${res}/intermediate2rdf.xsl"/>

		<echo>run_intermediate2rdf : done.</echo>
	</target>




	<!-- target run_intermediate2gvd : generates Object Graphs (graphviz tool) from intermediate model -->
	<!-- note : this target not included in the standard pipeline : run it manually -->
	<target name="run_intermediate2gvd" if="graphviz.path">
		<echo>run_vo-run_intermediate2gvd : starting generate GraphViz from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/html/${project.name}.gvd" style="${res}/intermediate2gvd.xsl" />

		<exec executable="${graphviz.path}" dir="${outputHTML}" >
			<arg value="-Tcmapx" />
			<arg value="-o${graphviz.map}" />
			<arg value="-Tpng"/>
			<arg value="-o${graphviz.png}"/>
			<arg value="${project.name}.gvd"/>
		</exec>
		<echo>run_intermediate2gvd : done.</echo>

	</target>


	<!-- target run_intermediate2ddl : generates DDL script from intermediate model -->
	<target name="run_intermediate2ddl">
		<echo>run_intermediate2ddl : starting generate DDL from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/ddl/ddl-gen.log" style="${res}/intermediate2ddl.xsl">
			<param name="vendor" expression="mssqlserver" />
			<param name="project_name" expression="${project.name}" />
			<param name="schema" expression="${tap.target_schema}" />
		</xslt2>

		<mkdir dir="${output}/ddl/mssqlserver/backup/" />
		<copy todir="${output}/ddl/mssqlserver/backup">
			<fileset dir="${output}/ddl/mssqlserver">
				<include name="dropTables.sql" />
				<include name="dropViews.sql" />
				<include name="backupTables.sql" />
				<include name="migrateTables.sql" />
				<include name="dropBackupTables.sql" />
			</fileset>
		</copy>
		<!--
		<xslt2 in="${output}/${source_intermediate}" out="${output}/ddl/ddl-gen.log" style="${res}/intermediate2ddl_singletable.xsl">
			<param name="vendor" expression="mssqlserver" />
			<param name="project_name" expression="${project.name}" />
			<param name="schema" expression="${tap.target_schema}" />
		</xslt2>
-->
		<xslt2 in="${output}/${source_intermediate}" out="${output}/ddl/ddl-gen.log" style="${res}/intermediate2ddl.xsl">
			<param name="vendor" expression="postgres" />
			<param name="project_name" expression="${project.name}" />
			<param name="schema" expression="${tap.target_schema}" />
		</xslt2>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/ddl/ddl-gen.log" style="${res}/intermediate2ddl.xsl" >
			<param name="vendor" expression="mysql" />
			<param name="project_name" expression="${project.name}" />
			<param name="schema" expression="${tap.target_schema}" />
		</xslt2>

		<echo>run_intermediate2ddl : done.</echo>
	</target>


	<target name="DB-rebuild" description="generate DDL, clean and create database structure">
		<ant target="run_intermediate2ddl"/>
		<!-- update DB if needed -->
		<ant target="DB-setup" />
	</target>



	<!-- target run_intermediate2tap : generates TAP metadata VOTables from intermediate model -->
	<target name="run_intermediate2tap">
		<echo>run_intermediate2tap : starting generate TAP metadata VOTables from file ${output}/${source_intermediate}</echo>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/tap/tap-gen.log" style="${res}/intermediate2tap.xsl">
			<param name="mode" expression="tableset" />
			<param name="project_name" expression="${project.name}" />
		</xslt2>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/tap/mssqlserver/tap-gen.log" style="${res}/intermediate2tap.xsl">
			<param name="mode" expression="tap_schema" />
			<param name="vendor" expression="mssqlserver" />
			<param name="target_database" expression="${tap.target_database}" />
			<param name="target_schema" expression="${tap.target_schema}" />
			<param name="project_name" expression="${project.name}" />
		</xslt2>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/tap/postgres/tap-gen.log" style="${res}/intermediate2tap.xsl">
			<param name="mode" expression="tap_schema" />
			<param name="vendor" expression="postgres" />
			<param name="target_database" expression="${tap.target_database}" />
			<param name="target_schema" expression="${tap.target_schema}" />
			<param name="project_name" expression="${project.name}" />
		</xslt2>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/tap/tap-gen.log" style="${res}/intermediate2tap.xsl">
			<param name="mode" expression="vodataservice" />
			<param name="project_name" expression="${project.name}" />
		</xslt2>

		<xslt2 in="${output}/${source_intermediate}" out="${output}/tap/tap-gen.log" style="${res}/intermediate2tap.xsl">
			<param name="mode" expression="votable" />
			<param name="project_name" expression="${project.name}" />
		</xslt2>

		<echo>run_intermediate2tap : done.</echo>
	</target>




	<!-- target run_intermediate2java : generates java classes from intermediate model -->
	<target name="run_intermediate2java">
		<echo>run_intermediate2java : starting filter on file ${output}/${source}</echo>

		<mkdir dir="${sources.gen}/" />
		<copy tofile="${properties}/persistence.xml" filtering="true" verbose="true" overwrite="true">
			<fileset file="${templates}/persistence-template.xml" />
			<filterset>
				<filter token="jpa.persistence.unit" value="${jpa.persistence.unit}" />
			</filterset>
		</copy>

		<copy tofile="${properties}/jpa-config.properties" filtering="true" verbose="true" overwrite="true">
			<fileset file="${templates}/jpa-config.properties.template" />
			<filterset>
				<filter token="jpa.database" value="${jpa.database}" />
				<filter token="targetdb.driver" value="${targetdb.driver}" />
				<filter token="targetdb.url" value="${targetdb.url}" />
				<filter token="targetdb.user" value="${targetdb.user}" />
				<filter token="targetdb.password" value="${targetdb.password}" />
				<filter token="targetdb.admin" value="${targetdb.admin}" />
				<filter token="targetdb.adminpassword" value="${targetdb.adminpassword}" />
			</filterset>
		</copy>


		<xslt2 in="${output}/${source_intermediate}" out="${sources.gen}/java-gen.log" style="${res}/intermediate2java.xsl">
			<param name="root_package" expression="${root_package}" />
			<param name="model_package" expression="${model_package}" />
			<param name="targetnamespace_root" expression="${targetnamespace_root}" />
			<param name="persistence.xml" expression="${properties}/persistence.xml"/>
			<param name="databaseSchema" expression="${tap.target_schema}" />
		</xslt2>

		<echo>run_intermediate2java : done.</echo>
	</target>


	<!-- include db targets -->

  &buildDB; 

  <!-- include java code targets -->

  &buildJava; 




    <!-- target echo : echos properties -->
	<target name="echo" depends="init">
		<echoproperties />
	</target>


	<target name="doNothing" >
		<echo>Doing nothing ......................................</echo>
	</target>


</project>