<?xml version="1.0" encoding="UTF-8"?>
<!--
  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 xmlns:ivy="antlib:org.apache.ivy.ant">

	<property name="project.webapp.dir" location="WebContent" />

	<import file="ivy-java-common.xml" />
	
    <target name="clean-webapp-lib" description="--> clean the project webapp libs directory">
        <delete includeemptydirs="true" dir="${project.weblib.dir}"/>
    </target>

	<target name="deploy-webapp" depends="compile-core, clean-webapp-lib">
		<ivy:cachepath pathid="project.core.class.path" conf="dev" />
		<copy todir="${servletEngine.webapp.dir}/${ant.project.name}/WEB-INF/classes">
			<fileset dir="${project.build.classes.dir}" />
		</copy>

		<copy todir="${servletEngine.webapp.dir}/${ant.project.name}">
			<fileset dir="${project.webapp.dir}" />
		</copy>
		<ivy:retrieve conf="deploy" pattern="${servletEngine.webapp.dir}/${ant.project.name}/WEB-INF/lib/[artifact]-[revision].[ext]"/>
		
		<antcall target="post-deploy-webapp" inheritRefs="true"/>
	</target>

	<target name="post-deploy-webapp" />

	<target name="undeploy-webapp">
		<delete dir="${servletEngine.webapp.dir}/${ant.project.name}" />
	</target>
	
	<target name="redeploy-webapp" description="replace current webapp" depends="undeploy-webapp, deploy-webapp"/>

</project>
