AbstractSchema.java

package org.jtheque.schemas;

import org.jtheque.core.utils.OSGiUtils;
import org.jtheque.persistence.DaoPersistenceContext;
import org.jtheque.utils.StringUtils;
import org.jtheque.utils.bean.EqualsBuilder;
import org.jtheque.utils.bean.HashCodeUtils;
import org.jtheque.utils.collections.ArrayUtils;

import org.osgi.framework.BundleContext;
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;

/*
 * Copyright JTheque (Baptiste Wicht)
 *
 * Licensed 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.
 */

/**
 * An abstract schema. The only thing this abstract class do is implementing the compareTo() method to ensure for good
 * order in collections.
 *
 * @author Baptiste Wicht
 */
public abstract class AbstractSchema implements Schema {
    private SimpleJdbcTemplate jdbcTemplate;

    private static final String ALTER_TABLE = "ALTER TABLE ";
    private static final String INSERT_INTO = "INSERT INTO ";
    private static final String CREATE_TABLE = "CREATE TABLE ";

    /**
     * Set the JDBC Template of the schema.
     *
     * @param jdbcTemplate The template to set.
     */
    public void setJdbcTemplate(SimpleJdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * Set the JDBC template of the schema using the bundle context to search it.
     *
     * @param bundleContext The bundle context to search for the JDBC template.
     */
    void setJdbcTemplate(BundleContext bundleContext) {
        DaoPersistenceContext daoPersistenceContext = OSGiUtils.getService(bundleContext, DaoPersistenceContext.class);

        jdbcTemplate = daoPersistenceContext.getTemplate();
    }

    /**
     * Return the jdbc template to execute JDBC request.
     *
     * @return The jdbc template.
     */
    protected SimpleJdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    /**
     * Update the the database executing the specified request.
     *
     * @param request The request to execute.
     * @param args    The args to give to the request.
     */
    protected void update(String request, Object... args) {
        jdbcTemplate.update(request, args);
    }

    /**
     * Alter the specified table using the specified command and args. All the {} will be replaced with the name of the
     * table.
     *
     * @param table   The table to alter.
     * @param command The command to alter the table with.
     * @param args    The args to fill the command with.
     */
    protected void alterTable(String table, String command, Object... args) {
        jdbcTemplate.update((ALTER_TABLE + table + ' ' + command).replace("{}", table), args);
    }

    /**
     * Create the specified table.
     *
     * @param table   The table to create.
     * @param columns The columns to create. The ( and ) are automatically added.
     */
    protected void createTable(String table, String columns) {
        jdbcTemplate.update(CREATE_TABLE + table + " (" + columns + ')');
    }

    /**
     * Update the database. All the {} will be replaced with the name of the specified table.
     *
     * @param table   The table to org.jtheque.update.
     * @param command The command to use to org.jtheque.update the database with.
     * @param args    The args to fill the command with.
     */
    protected void updateTable(CharSequence table, String command, Object... args) {
        jdbcTemplate.update(command.replace("{}", table), args);
    }

    /**
     * Create an insert request for the specified table.
     *
     * @param table  The table to insert into.
     * @param values The values of the insert request.
     *
     * @return The insert into request.
     */
    protected static String insert(String table, String values) {
        return INSERT_INTO + table + ' ' + values;
    }

    @Override
    public final int compareTo(Schema other) {
        boolean hasDependency = StringUtils.isNotEmpty(getDependencies());
        boolean hasOtherDependency = StringUtils.isNotEmpty(other.getDependencies());

        if (hasDependency && !hasOtherDependency) {
            return 1;
        } else if (!hasDependency && hasOtherDependency) {
            return -1;
        } else {
            //The other depends on me
            if (ArrayUtils.contains(other.getDependencies(), getId())) {
                return -1;
            }

            //I depends on the other
            if (ArrayUtils.contains(getDependencies(), other.getId())) {
                return 1;
            }
        }

        return 0;
    }

    @Override
    public int hashCode() {
        return HashCodeUtils.hashCodeDirect(getVersion(), getId(), getDependencies());
    }

    @Override
    public boolean equals(Object o) {
        if (o instanceof Schema) {
            Schema other = (Schema) o;

            return EqualsBuilder.newBuilder(this, other).
                    addField(getId(), other.getId()).
                    addField(getVersion(), other.getVersion()).
                    areEquals();
        }

        return false;
    }

    @Override
    public final String toString() {
        return getId() + ':' + getVersion();
    }
}