package org.apache.torque.mojo;

 /*

  * 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.

  */

 import java.io.File;

 import java.lang.reflect.InvocationTargetException;

 import java.sql.Connection;

 import java.sql.SQLException;

 import java.util.Collection;

 import java.util.Map;

 import java.util.Properties;

 import java.util.Vector;

 import org.apache.commons.beanutils.BeanUtils;

 import org.apache.commons.lang.StringUtils;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.settings.Server;

 import org.apache.maven.shared.filtering.MavenFileFilter;

 import org.apache.torque.engine.platform.Platform;

 import org.apache.torque.engine.platform.PlatformFactory;

 import org.apache.torque.util.JdbcConfigurer;

 import org.apache.torque.util.MojoDatabaseListener;

 import org.kuali.core.db.torque.PropertyHandlingException;

 import org.kuali.core.db.torque.Utils;

 import org.kuali.db.ConnectionHandler;

 import org.kuali.db.Credentials;

 import org.kuali.db.JDBCUtils;

 import org.kuali.db.SQLExecutor;

 import org.kuali.db.Transaction;

 import static org.apache.commons.lang.StringUtils.*;

 /**

  * Abstract mojo for making use of SQLExecutor

  */

 public abstract class AbstractSQLExecutorMojo extends BaseMojo {

         Utils utils = new Utils();

         JDBCUtils jdbcUtils;

         ConnectionHandler connectionHandler;

         Platform platform;

         public static final String DRIVER_INFO_PROPERTIES_USER = "user";

         public static final String DRIVER_INFO_PROPERTIES_PASSWORD = "password";

         /**

          * Call {@link #setOrder(String)} with this value to sort in ascendant order the sql files.

          */

         public static final String FILE_SORTING_ASC = "ascending";

         /**

          * Call {@link #setOrder(String)} with this value to sort in descendant order the sql files.

          */

         public static final String FILE_SORTING_DSC = "descending";

         // ////////////////////////// User Info ///////////////////////////////////

         /**

          * The type of database we are targeting (eg oracle, mysql). This is optional if <code>url</code> is supplied as the

          * database type will be automatically detected based on the <code>url</code>. If targetDatabase is explicitly

          * supplied it will override the type selected by the automatic detection logic.

          * 

          * @parameter expression="${targetDatabase}"

          */

         String targetDatabase;

         /**

          * Database username. If not given, it will be looked up through <code>settings.xml</code>'s server with

          * <code>${settingsKey}</code> as key.

          * 

          * @parameter expression="${username}"

          */

         String username;

         /**

          * Database password. If not given, it will be looked up through <code>settings.xml</code>'s server with

          * <code>${settingsKey}</code> as key.

          * 

          * @parameter expression="${password}"

          */

         String password;

         /**

          * Ignore the password and use anonymous access.

          * 

          * @parameter expression="${enableAnonymousPassword}" default-value="false"

          */

         boolean enableAnonymousPassword;

         /**

          * Ignore the username and use anonymous access.

          * 

          * @parameter expression="${enableAnonymousUsername}" default-value="false"

          */

         boolean enableAnonymousUsername;

         /**

          * Additional key=value pairs separated by a comma to be passed to JDBC driver.

          * 

          * @parameter expression="${driverProperties}" default-value=""

          */

         String driverProperties;

         /**

          * If set to true the password being used to connect to the database will be displayed in log messages.

          * 

          * @parameter expression="${showPassword}" default-value="false"

          */

         boolean showPassword;

         /**

          * The id of the server in settings.xml containing the username/password to use.

          * 

          * @parameter expression="${settingsKey}" default-value="impex.${project.artifactId}"

          */

         String settingsKey;

         /**

          * Skip execution if there is an error obtaining a connection. If this is set to true, the build will continue even

          * if there is an error obtaining a connection

          * 

          * @parameter expression="${skipOnConnectionError}" default-value="false"

          */

         boolean skipOnConnectionError;

         /**

          * SQL input commands separated by <code>${delimiter}</code>.

          * 

          * @parameter expression="${sqlCommand}" default-value=""

          */

         String sqlCommand = "";

         /**

          * List of files containing SQL statements to load.

          * 

          * @parameter expression="${srcFiles}"

          */

         File[] srcFiles;

         // //////////////////////////////// Database info /////////////////////////

         /**

          * Database URL.

          * 

          * @parameter expression="${url}"

          */

         String url;

         /**

          * Database driver classname. This parameter is optional, as the correct JDBC driver to use is detected from the

          * <code>url</code> in almost all cases (works for Oracle, MySQL, Derby, PostGresSQL, DB2, H2, HSQL, SQL Server). If

          * a driver is explicitly supplied, it will be used in place of the JDBC driver the automatic detection logic would

          * have chosen.

          * 

          * @parameter expression="${driver}"

          */

         String driver;

         // //////////////////////////// Operation Configuration ////////////////////

         /**

          * Set to <code>true</code> to execute non-transactional SQL.

          * 

          * @parameter expression="${autocommit}" default-value="false"

          */

         boolean autocommit;

         /**

          * Action to perform if an error is found. Possible values are <code>abort</code> and <code>continue</code>.

          * 

          * @parameter expression="${onError}" default-value="abort"

          */

         String onError = SQLExecutor.ON_ERROR_ABORT;

         // //////////////////////////// Parser Configuration ////////////////////

         /**

          * Set the delimiter that separates SQL statements.

          * 

          * @parameter expression="${delimiter}" default-value="/"

          */

         String delimiter = "/";

         /**

          * The delimiter type takes two values - "normal" and "row". Normal means that any occurrence of the delimiter

          * terminate the SQL command whereas with row, only a line containing just the delimiter is recognized as the end of

          * the command.<br>

          * <br>

          * For example, set this to "go" and delimiterType to "row" for Sybase ASE or MS SQL Server.

          * 

          * @parameter expression="${delimiterType}" default-value="row"

          */

         String delimiterType = DelimiterType.ROW;

         /**

          * Keep the format of an SQL block.

          * 

          * @parameter expression="${keepFormat}" default-value="true"

          */

         boolean keepFormat = true;

         /**

          * Print header columns.

          * 

          * @parameter expression="${showheaders}" default-value="true"

          */

         boolean showheaders = true;

         /**

          * If writing output to a file, append to an existing file or overwrite it?

          * 

          * @parameter expression="${append}" default-value="false"

          */

         boolean append = false;

         /**

          * Argument to Statement.setEscapeProcessing If you want the driver to use regular SQL syntax then set this to

          * false.

          * 

          * @parameter expression="${escapeProcessing}" default-value="true"

          */

         boolean escapeProcessing = true;

         // //////////////////////////////// Internal properties//////////////////////

         /**

          * number of successful executed statements

          */

         int successfulStatements = 0;

         /**

          * number of total executed statements

          */

         int totalStatements = 0;

         /**

          * Database connection

          */

         Connection conn = null;

         /**

          * SQL transactions to perform

          */

         Vector<Transaction> transactions = new Vector<Transaction>();

         /**

          * @component role="org.apache.maven.shared.filtering.MavenFileFilter"

          */

         MavenFileFilter fileFilter;

         /**

          * The credentials to use for database access

          */

         Credentials credentials;

         protected void configureTransactions() throws MojoExecutionException {

                 // default implementation does nothing

         }

         protected Properties getContextProperties() {

                 Properties properties = new Properties();

                 Map<String, String> environment = System.getenv();

                 for (String key : environment.keySet()) {

                         properties.put("env." + key, environment.get(key));

                 }

                 properties.putAll(getProject().getProperties());

                 properties.putAll(System.getProperties());

                 return properties;

         }

         protected Credentials getNewCredentials() {

                 Credentials credentials = new Credentials();

                 credentials.setUsername(getUsername());

                 credentials.setPassword(getPassword());

                 return credentials;

         }

         protected ConnectionHandler getNewConnectionHandler() throws MojoExecutionException {

                 ConnectionHandler connectionHandler = new ConnectionHandler();

                 try {

                         BeanUtils.copyProperties(connectionHandler, this);

                         return connectionHandler;

                 } catch (Exception e) {

                         throw new MojoExecutionException("Error establishing connection", e);

                 }

         }

         /**

          * Validate our configuration and execute SQL as appropriate

          * 

          * @throws MojoExecutionException

          */

         public void executeMojo() throws MojoExecutionException {

                 jdbcUtils = new JDBCUtils();

                 updateConfiguration();

                 Credentials credentials = getNewCredentials();

                 updateCredentials(credentials);

                 validateCredentials(credentials);

                 setCredentials(credentials);

                 validateConfiguration();

                 connectionHandler = getNewConnectionHandler();

                 conn = getConnection();

                 if (connectionHandler.isConnectionError() && skipOnConnectionError) {

                         // There was an error obtaining a connection

                         // Do not fail the build but don't do anything more

                         return;

                 }

                 // Configure the transactions we will be running

                 configureTransactions();

                 // Make sure our counters are zeroed out

                 successfulStatements = 0;

                 totalStatements = 0;

                 // Get an SQLExecutor

                 SQLExecutor executor = getSqlExecutor();

                 try {

                         executor.execute();

                 } catch (SQLException e) {

                         throw new MojoExecutionException("Error executing SQL", e);

                 }

         }

         /**

          * Set an inline SQL command to execute.

          * 

          * @param sql

          *            the sql statement to add

          */

         public void addText(String sql) {

                 this.sqlCommand += sql;

         }

         /**

          * Set the delimiter that separates SQL statements. Defaults to ";";

          * 

          * @param delimiter

          *            the new delimiter

          */

         public void setDelimiter(String delimiter) {

                 this.delimiter = delimiter;

         }

         /**

          * Set the delimiter type: "normal" or "row" (default "normal").

          * 

          * @param delimiterType

          *            the new delimiterType

          */

         public void setDelimiterType(String delimiterType) {

                 this.delimiterType = delimiterType;

         }

         /**

          * Print headers for result sets from the statements; optional, default true.

          * 

          * @param showheaders

          *            <code>true</code> to show the headers, otherwise <code>false</code>

          */

         public void setShowheaders(boolean showheaders) {

                 this.showheaders = showheaders;

         }

         /**

          * whether output should be appended to or overwrite an existing file. Defaults to false.

          * 

          * @param append

          *            <code>true</code> to append, otherwise <code>false</code> to overwrite

          */

         public void setAppend(boolean append) {

                 this.append = append;

         }

         /**

          * whether or not format should be preserved. Defaults to false.

          * 

          * @param keepformat

          *            The keepformat to set

          */

         public void setKeepFormat(boolean keepformat) {

                 this.keepFormat = keepformat;

         }

         /**

          * Set escape processing for statements.

          * 

          * @param enable

          *            <code>true</code> to escape, otherwiser <code>false</code>

          */

         public void setEscapeProcessing(boolean enable) {

                 escapeProcessing = enable;

         }

         protected SQLExecutor getSqlExecutor() throws MojoExecutionException {

                 try {

                         SQLExecutor executor = new SQLExecutor();

                         BeanUtils.copyProperties(executor, this);

                         executor.addListener(new MojoDatabaseListener(getLog()));

                         return executor;

                 } catch (InvocationTargetException e) {

                         throw new MojoExecutionException("Error copying properties from the mojo to the SQL executor", e);

                 } catch (IllegalAccessException e) {

                         throw new MojoExecutionException("Error copying properties from the mojo to the SQL executor", e);

                 }

         }

         /**

          * Attempt to automatically detect the correct JDBC driver and database type (oracle, mysql, h2, derby, etc) given a

          * JDBC url

          */

         protected void updateConfiguration() throws MojoExecutionException {

                 try {

                         new JdbcConfigurer().updateConfiguration(this);

                 } catch (PropertyHandlingException e) {

                         throw new MojoExecutionException("Error handling properties", e);

                 }

                 platform = PlatformFactory.getPlatformFor(targetDatabase);

         }

         /**

          * Validate that some essential configuration items are present

          */

         protected void validateConfiguration() throws MojoExecutionException {

                 new JdbcConfigurer().validateConfiguration(this);

         }

         protected void validateCredentials(Credentials credentials, boolean anonymousAccessAllowed, String validationFailureMessage) throws MojoExecutionException {

                 if (anonymousAccessAllowed) {

                         // If credentials aren't required, don't bother validating

                         return;

                 }

                 String username = credentials.getUsername();

                 String password = credentials.getPassword();

                 if (!isEmpty(username) && !isEmpty(password)) {

                         // Both are required, and both have been supplied

                         return;

                 }

                 throw new MojoExecutionException(validationFailureMessage);

         }

         protected void validateCredentials(Credentials credentials) throws MojoExecutionException {

                 // Both are required but one (or both) are missing

                 StringBuffer sb = new StringBuffer();

                 sb.append("\n\n");

                 sb.append("Username and password must be specified.\n");

                 sb.append("Specify them in the plugin configuration or as a system property.\n");

                 sb.append("\n");

                 sb.append("For example:\n");

                 sb.append("-Dusername=myuser\n");

                 sb.append("-Dpassword=mypassword\n");

                 sb.append("\n.");

                 validateCredentials(credentials, enableAnonymousUsername && enableAnonymousPassword, sb.toString());

         }

         protected boolean isNullOrEmpty(Collection<?> c) {

                 if (c == null) {

                         return true;

                 }

                 if (c.size() == 0) {

                         return true;

                 }

                 return false;

         }

         protected String convertNullToEmpty(String s) {

                 if (s == null) {

                         return "";

                 } else {

                         return s;

                 }

         }

         /**

          * Load username/password from settings.xml if user has not set them in JVM properties

          * 

          * @throws MojoExecutionException

          */

         protected void updateCredentials(Credentials credentials) {

                 Server server = getServerFromSettingsKey();

                 String username = getUpdatedUsername(server, credentials.getUsername());

                 String password = getUpdatedPassword(server, credentials.getPassword());

                 credentials.setUsername(convertNullToEmpty(username));

                 credentials.setPassword(convertNullToEmpty(password));

         }

         protected Server getServerFromSettingsKey() {

                 Server server = getSettings().getServer(getSettingsKey());

                 if (server == null) {

                         // Fall through to using the JDBC url as a key

                         return getSettings().getServer("impex." + getUrl());

                 } else {

                         return null;

                 }

         }

         protected String getUpdatedPassword(Server server, String password) {

                 // They already gave us a password, don't mess with it

                 if (!isEmpty(password)) {

                         return password;

                 }

                 if (server != null) {

                         // We've successfully located a server in settings.xml, use the password from that

                         getLog().info("Located a password in settings.xml under the server id '" + server.getId() + "' Password: " + getDisplayPassword(server.getPassword()));

                         return server.getPassword();

                 }

                 getLog().info("Using default password generated from the artifact id");

                 return platform.getSchemaName(getProject().getArtifactId());

         }

         protected String getDisplayPassword(String password) {

                 if (isShowPassword()) {

                         return password;

                 } else {

                         return StringUtils.repeat("*", password.length());

                 }

         }

         protected String getUpdatedUsername(Server server, String username) {

                 // They already gave us a username, don't mess with it

                 if (!isEmpty(username)) {

                         return username;

                 }

                 if (server != null) {

                         // We've successfully located a server in settings.xml, use the username from that

                         getLog().info("Located a username in settings.xml under the server id '" + server.getId() + "' Username: " + server.getUsername());

                         return server.getUsername();

                 }

                 getLog().info("Using default username generated from the artifact id");

                 return platform.getSchemaName(getProject().getArtifactId());

         }

         /**

          * Creates a new Connection as using the driver, url, userid and password specified.

          * 

          * The calling method is responsible for closing the connection.

          * 

          * @return Connection the newly created connection.

          * @throws MojoExecutionException

          *             if the UserId/Password/Url is not set or there is no suitable driver or the driver fails to load.

          * @throws SQLException

          *             if there is problem getting connection with valid url

          * 

          */

         protected Connection getConnection() throws MojoExecutionException {

                 try {

                         return connectionHandler.getConnection();

                 } catch (Exception e) {

                         throw new MojoExecutionException("Error establishing connection", e);

                 }

         }

         /**

          * parse driverProperties into Properties set

          * 

          * @return the driver properties

          * @throws MojoExecutionException

          */

         protected Properties getDriverProperties() throws MojoExecutionException {

                 Properties properties = new Properties();

                 if (isEmpty(this.driverProperties)) {

                         return properties;

                 }

                 String[] tokens = split(this.driverProperties, ",");

                 for (int i = 0; i < tokens.length; ++i) {

                         String[] keyValueTokens = split(tokens[i].trim(), "=");

                         if (keyValueTokens.length != 2) {

                                 throw new MojoExecutionException("Invalid JDBC Driver properties: " + this.driverProperties);

                         }

                         properties.setProperty(keyValueTokens[0], keyValueTokens[1]);

                 }

                 return properties;

         }

         public String getUsername() {

                 return this.username;

         }

         public void setUsername(String username) {

                 this.username = username;

         }

         public String getPassword() {

                 return this.password;

         }

         public void setPassword(String password) {

                 this.password = password;

         }

         public String getUrl() {

                 return this.url;

         }

         public void setUrl(String url) {

                 this.url = url;

         }

         public String getDriver() {

                 return this.driver;

         }

         public void setDriver(String driver) {

                 this.driver = driver;

         }

         public void setAutocommit(boolean autocommit) {

                 this.autocommit = autocommit;

         }

         public File[] getSrcFiles() {

                 return this.srcFiles;

         }

         public void setSrcFiles(File[] files) {

                 this.srcFiles = files;

         }

         /**

          * Number of SQL statements executed so far that caused errors.

          * 

          * @return the number

          */

         public int getSuccessfulStatements() {

                 return successfulStatements;

         }

         /**

          * Number of SQL statements executed so far, including the ones that caused errors.

          * 

          * @return the number

          */

         public int getTotalStatements() {

                 return totalStatements;

         }

         public String getOnError() {

                 return this.onError;

         }

         public void setOnError(String action) {

                 if (SQLExecutor.ON_ERROR_ABORT.equalsIgnoreCase(action)) {

                         this.onError = SQLExecutor.ON_ERROR_ABORT;

                 } else if (SQLExecutor.ON_ERROR_CONTINUE.equalsIgnoreCase(action)) {

                         this.onError = SQLExecutor.ON_ERROR_CONTINUE;

                 } else if (SQLExecutor.ON_ERROR_ABORT_AFTER.equalsIgnoreCase(action)) {

                         this.onError = SQLExecutor.ON_ERROR_ABORT_AFTER;

                 } else {

                         throw new IllegalArgumentException(action + " is not a valid value for onError, only '" + SQLExecutor.ON_ERROR_ABORT + "', '" + SQLExecutor.ON_ERROR_ABORT_AFTER + "', or '" + SQLExecutor.ON_ERROR_CONTINUE + "'.");

                 }

         }

         public void setSettingsKey(String key) {

                 this.settingsKey = key;

         }

         public void setDriverProperties(String driverProperties) {

                 this.driverProperties = driverProperties;

         }

         public String getSqlCommand() {

                 return sqlCommand;

         }

         public void setSqlCommand(String sqlCommand) {

                 this.sqlCommand = sqlCommand;

         }

         public Vector<Transaction> getTransactions() {

                 return transactions;

         }

         public void setTransactions(Vector<Transaction> transactions) {

                 this.transactions = transactions;

         }

         public void setFileFilter(MavenFileFilter filter) {

                 this.fileFilter = filter;

         }

         public String getTargetDatabase() {

                 return targetDatabase;

         }

         public void setTargetDatabase(String targetDatabase) {

                 this.targetDatabase = targetDatabase;

         }

         public Connection getConn() {

                 return conn;

         }

         public void setConn(Connection conn) {

                 this.conn = conn;

         }

         public String getDelimiter() {

                 return delimiter;

         }

         public String getDelimiterType() {

                 return delimiterType;

         }

         public boolean isKeepFormat() {

                 return keepFormat;

         }

         public boolean isShowheaders() {

                 return showheaders;

         }

         public boolean isAppend() {

                 return append;

         }

         public boolean isEscapeProcessing() {

                 return escapeProcessing;

         }

         public boolean isSkipOnConnectionError() {

                 return skipOnConnectionError;

         }

         public void setSkipOnConnectionError(boolean skipOnConnectionError) {

                 this.skipOnConnectionError = skipOnConnectionError;

         }

         public MavenFileFilter getFileFilter() {

                 return fileFilter;

         }

         public boolean isShowPassword() {

                 return showPassword;

         }

         public void setShowPassword(boolean showPassword) {

                 this.showPassword = showPassword;

         }

         public boolean isEnableAnonymousPassword() {

                 return enableAnonymousPassword;

         }

         public void setEnableAnonymousPassword(boolean enableAnonymousPassword) {

                 this.enableAnonymousPassword = enableAnonymousPassword;

         }

         public String getSettingsKey() {

                 return settingsKey;

         }

         public boolean isAutocommit() {

                 return autocommit;

         }

         public void setSuccessfulStatements(int successfulStatements) {

                 this.successfulStatements = successfulStatements;

         }

         public void setTotalStatements(int totalStatements) {

                 this.totalStatements = totalStatements;

         }

         public void setCredentials(Credentials credentials) {

                 this.credentials = credentials;

         }

         public Credentials getCredentials() {

                 return credentials;

         }

 }