<!--
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
-->

<project name="sample-chat2-webapp" default="compile">

    <target name="compile">
        <mkdir dir="target/classes"/>
        <javac destdir="target/classes" debug="on" source="1.5" target="1.5">
            <src path="src\main\java"/>
            <classpath>
                <fileset refid="tuscany.jars"/>
                <fileset refid="3rdparty.jars"/>
            </classpath>
        </javac>
        <copy todir="target/classes">
            <fileset dir="src\main\resources"/>
            <fileset dir="." includes="*" excludes="src, target, pom.xml, build.xml"/>
        </copy>
        <war destfile="target/sample-chat2-webapp.war" webxml="src/main/webapp/WEB-INF/web.xml">
            <fileset dir="src/main/webapp"/>
            <lib refid="tuscany.jars"/>
            <lib refid="3rdparty.jars"/>
            <classes dir="target/classes"/>
        </war>
    </target>

    <target name="package" depends="compile"/>

    <target name="clean">
        <delete includeemptydirs="true">
            <fileset dir="target"/>
        </delete>
    </target>

    <fileset id="tuscany.jars" dir="../../modules">
        <include name="tuscany-assembly-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-assembly-xml-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-assembly-xsd-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-binding-dwr-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-binding-sca-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-binding-sca-xml-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-contribution-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-contribution-impl-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-contribution-java-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-contribution-namespace-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-contribution-resource-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-contribution-xml-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-core-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-core-databinding-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-core-spi-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-databinding-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-databinding-jaxb-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-definitions-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-definitions-xml-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-domain-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-domain-api-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-extensibility-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-extension-helper-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-host-embedded-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-host-http-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-host-webapp-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-implementation-java-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-implementation-java-runtime-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-implementation-java-xml-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-implementation-web-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-interface-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-interface-java-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-interface-java-jaxws-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-interface-java-xml-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-node-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-node-api-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-policy-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-policy-xml-1.7-SNAPSHOT.jar"/>
        <include name="tuscany-sca-api-1.7-SNAPSHOT.jar"/>
    </fileset>
    <fileset id="3rdparty.jars" dir="../../lib">
        <include name="activation-1.1.jar"/>
        <include name="axiom-api-1.2.5.jar"/>
        <include name="axiom-impl-1.2.5.jar"/>
        <include name="cglib-nodep-2.1_3.jar"/>
        <include name="commons-logging-1.1.jar"/>
        <include name="dwr-2.0.1.jar"/>
        <include name="geronimo-commonj_1.1_spec-1.0.jar"/>
        <include name="jaxb-api-2.1.jar"/>
        <include name="jaxb-impl-2.1.6.jar"/>
        <include name="jaxb2-reflection-2.1.4.jar"/>
        <include name="jaxen-1.1-beta-9.jar"/>
        <include name="jaxws-api-2.1.jar"/>
        <include name="jsr181-api-1.0-MR1.jar"/>
        <include name="jsr250-api-1.0.jar"/>
        <include name="mail-1.4.jar"/>
        <include name="neethi-2.0.2.jar"/>
        <include name="saaj-api-1.3.jar"/>
        <include name="stax-api-1.0-2.jar"/>
        <include name="wstx-asl-3.2.1.jar"/>
        <include name="xalan-2.7.0.jar"/>
        <include name="xercesImpl-2.8.1.jar"/>
        <include name="xml-apis-1.3.03.jar"/>
    </fileset>

</project>
