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();
}
}