/**
* Licensed under the GNU LESSER GENERAL PUBLIC LICENSE, version 2.1, dated February 1999.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the latest version of the GNU Lesser General
* Public License as published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program (LICENSE.txt); if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
package org.jamwiki.db;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import org.apache.commons.lang.StringUtils;
import org.jamwiki.DataAccessException;
import org.jamwiki.Environment;
import org.jamwiki.WikiBase;
import org.jamwiki.WikiException;
import org.jamwiki.authentication.RoleImpl;
import org.jamwiki.model.OS;
import org.jamwiki.model.Role;
import org.jamwiki.model.Topic;
import org.jamwiki.model.TopicVersion;
import org.jamwiki.model.VirtualWiki;
import org.jamwiki.model.WikiGroup;
import org.jamwiki.model.WikiUser;
import org.jamwiki.utils.WikiLogger;
import org.jamwiki.utils.WikiUtil;
import org.springframework.transaction.TransactionStatus;
/**
* This class contains general database utility methods that are useful for a
* variety of JAMWiki database functions, including setup and upgrades.
*/
public class WikiDatabase {
private static String CONNECTION_VALIDATION_QUERY = null;
private static String EXISTENCE_VALIDATION_QUERY = null;
private static final WikiLogger logger = WikiLogger
.getLogger(WikiDatabase.class.getName());
// private static final String[][] JAMWIKI_DB_TABLE_INFO = {
// {"jam_virtual_wiki", "virtual_wiki_id"},
// {"jam_users", null},
// {"jam_wiki_user", "wiki_user_id"},
// {"jam_topic", "topic_id"},
// {"jam_topic_version", "topic_version_id"},
// {"jam_file", "file_id"},
// {"jam_file_version", "file_version_id"},
// {"jam_category", null},
// {"jam_group", "group_id"},
// {"jam_group_members", "id"},
// {"jam_role", null},
// {"jam_authorities", null},
// {"jam_group_authorities", null},
// {"jam_recent_change", "topic_version_id"},
// {"jam_watchlist", null}
// };
/**
*
*/
private WikiDatabase() {
}
// /**
// * Dump the database to a CSV file. This is an HSQL-specific method useful
// * for individuals who want to convert from HSQL to another database.
// */
// public static void exportToCsv() throws DataAccessException, SQLException {
// if (!(WikiBase.getDataHandler() instanceof HSqlDataHandler)) {
// throw new
// IllegalStateException("Exporting to CSV is allowed only when the wiki is configured to use the internal database setting.");
// }
// PreparedStatement stmt = null;
// Connection conn = null;
// String sql = null;
// String exportTableName = null;
// String csvDirectory = new
// File(Environment.getValue(Environment.PROP_BASE_FILE_DIR),
// "database").getPath();
// File csvFile = null;
// TransactionStatus status = DatabaseConnection.startTransaction();
// try {
// conn = DatabaseConnection.getConnection();
// // make sure CSV files are encoded UTF-8
// // TODO: this does not seem to be working currently - HSQL bug?
// sql = "set property \"textdb.encoding\" 'UTF-8'";
// stmt = conn.prepareStatement(sql);
// stmt.executeUpdate();
// for (int i=0; i < JAMWIKI_DB_TABLE_INFO.length; i++) {
// exportTableName = JAMWIKI_DB_TABLE_INFO[i][0] + "_export";
// // first drop any pre-existing CSV database files.
// sql = "drop table " + exportTableName + " if exists";
// stmt = conn.prepareStatement(sql);
// stmt.executeUpdate();
// // now delete the CSV file if it exists
// csvFile = new File(csvDirectory, exportTableName + ".csv");
// if (csvFile.exists()) {
// if (csvFile.delete()) {
// logger.info("Deleted existing CSV file: " + csvFile.getPath());
// } else {
// logger.warning("Could not delete existing CSV file: " + csvFile.getPath());
// }
// }
// // create the CSV files
// sql = "select * into text " + exportTableName + " from " +
// JAMWIKI_DB_TABLE_INFO[i][0];
// stmt = conn.prepareStatement(sql);
// stmt.executeUpdate();
// }
// // rebuild the data files to make sure everything is committed to disk
// sql = "checkpoint";
// stmt = conn.prepareStatement(sql);
// stmt.executeUpdate();
// } catch (Exception e) {
// DatabaseConnection.rollbackOnException(status, e);
// throw new DataAccessException(e);
// } catch (Error err) {
// DatabaseConnection.rollbackOnException(status, err);
// throw new DataAccessException(err);
// } finally {
// DatabaseConnection.closeStatement(stmt);
// }
// DatabaseConnection.commit(status);
// }
//
// /**
// *
// */
// private static DataHandler findNewDataHandler(Properties props) {
// // find the DataHandler appropriate to the NEW database
// String handlerClassName = props.getProperty(Environment.PROP_DB_TYPE);
// if
// (handlerClassName.equals(Environment.getValue(Environment.PROP_DB_TYPE))) {
// // use existing DataHandler
// return WikiBase.getDataHandler();
// }
// logger.fine("Using NEW data handler: " + handlerClassName);
// return (DataHandler)Utilities.instantiateClass(handlerClassName);
// }
//
// /**
// * Migrate from the current database to a new database.
// * Tables are created in the new database, and then the contents
// * of the existing database are transferred across.
// *
// * @param props Properties object containing the new database properties
// * @param errors List to add error messages to
// */
// public static void migrateDatabase(Properties props, List<WikiMessage>
// errors) throws DataAccessException {
// // verify that new database is different from the old database
// if
// (StringUtils.equalsIgnoreCase(Environment.getValue(Environment.PROP_DB_URL),
// props.getProperty(Environment.PROP_DB_URL))) {
// errors.add(new WikiMessage("error.databaseconnection",
// "Cannot migrate to the same database"));
// return;
// }
// // find the DataHandler appropriate to the NEW database
// DataHandler newDataHandler = WikiDatabase.findNewDataHandler(props);
// // the QueryHandler appropriate for the NEW database
// QueryHandler newQueryHandler = null;
// // FIXME - this is ugly
// if (newDataHandler instanceof AnsiDataHandler) {
// AnsiDataHandler dataHandler = (AnsiDataHandler)newDataHandler;
// newQueryHandler = dataHandler.queryHandler();
// logger.fine("Using NEW query handler: " +
// newQueryHandler.getClass().getName());
// } else {
// newQueryHandler = queryHandler();
// }
// Connection conn = null;
// Connection from = null;
// Statement stmt = null;
// ResultSet rs = null;
// try {
// // create the tables in the NEW database
// conn = WikiDatabase.initializeNewDatabase(props, errors, newQueryHandler);
// if (conn == null) {
// return;
// }
// // since this is a new database setting autocommit to true is ok. in
// addition,
// // since a potentially huge amount of data might be getting committed it
// prevents
// // locking issues when loading the database.
// conn.setAutoCommit(true);
// // copy the existing table content from the CURRENT database across to the
// NEW database
// from = DatabaseConnection.getConnection();
// from.setReadOnly(true);
// from.setAutoCommit(true);
// // used to track current_version_id for each jam_topic row inserted
// Map<Integer, Integer> topicVersions = new HashMap<Integer, Integer>();
// for (int i = 0; i < JAMWIKI_DB_TABLE_INFO.length; i++) {
// // these 3 variables are for special handling of the
// jam_topic.current_version_id field
// // which cannot be loaded on initial insert due to the jam_f_topic_topicv
// constraint
// boolean isTopicTable = "jam_topic".equals(JAMWIKI_DB_TABLE_INFO[i][0]);
// int topicIdColumn = 0;
// int currentVersionColumn = 0;
// int maxIndex =
// WikiDatabase.retrieveMaximumTableId(JAMWIKI_DB_TABLE_INFO[i][0],
// JAMWIKI_DB_TABLE_INFO[i][1]);
// StringBuilder insert;
// ResultSetMetaData md;
// StringBuilder values;
// StringBuilder select;
// String columnName;
// Integer topicId;
// Integer currentVersionId;
// Object o;
// // cycle through at most RECORDS_PER_CYCLE records at a time to avoid
// blowing up the system
// int RECORDS_PER_CYCLE = 25;
// for (int j = 0; j <= maxIndex; j += RECORDS_PER_CYCLE) {
// select = new
// StringBuilder("SELECT * FROM ").append(JAMWIKI_DB_TABLE_INFO[i][0]);
// if (!StringUtils.isBlank(JAMWIKI_DB_TABLE_INFO[i][1])) {
// select.append(" WHERE ").append(JAMWIKI_DB_TABLE_INFO[i][1]).append(" > ").append(j);
// select.append(" AND ").append(JAMWIKI_DB_TABLE_INFO[i][1]).append(" <= ").append(j
// + RECORDS_PER_CYCLE);
// select.append(" ORDER BY ").append(JAMWIKI_DB_TABLE_INFO[i][1]);
// }
// insert = new StringBuilder();
// stmt = from.createStatement();
// logger.info(select.toString());
// rs = stmt.executeQuery(select.toString());
// md = rs.getMetaData();
// insert.append("INSERT INTO ").append(JAMWIKI_DB_TABLE_INFO[i][0]).append('(');
// values = new StringBuilder();
// for (int k = 1; k <= md.getColumnCount(); k++) {
// if (k > 1) {
// insert.append(',');
// values.append(',');
// }
// columnName = md.getColumnLabel(k);
// if (isTopicTable) {
// if ("topic_id".equalsIgnoreCase(columnName)) {
// topicIdColumn = k;
// } else if ("current_version_id".equalsIgnoreCase(columnName)) {
// currentVersionColumn = k;
// }
// }
// // special handling for Sybase ASA, which requires the "login" column name
// to be quoted
// if (newQueryHandler instanceof org.jamwiki.db.SybaseASAQueryHandler &&
// "login".equalsIgnoreCase(columnName)) {
// columnName = "\"" + columnName + "\"";
// }
// insert.append(columnName);
// values.append('?');
// }
// insert.append(") VALUES (").append(values).append(')');
// logger.info(insert.toString());
// PreparedStatement insertStmt = conn.prepareStatement(insert.toString());
// while (rs.next()) {
// topicId = null;
// currentVersionId = null;
// for (int k = 1; k <= md.getColumnCount(); k++) {
// o = rs.getObject(k);
// if (isTopicTable) {
// if (k == topicIdColumn) {
// topicId = (Integer)o;
// } else if (k == currentVersionColumn) {
// currentVersionId = (Integer)o;
// }
// }
// if (rs.wasNull() || (isTopicTable && k == currentVersionColumn)) {
// insertStmt.setNull(k, md.getColumnType(k));
// } else {
// insertStmt.setObject(k, rs.getObject(k));
// }
// }
// insertStmt.executeUpdate();
// if (topicId != null && currentVersionId != null) {
// // store current topic version for later update. since topic id is the
// // map key, any older (obsolete) topic version IDs will be overwritten
// // as later records are processed.
// topicVersions.put(topicId, currentVersionId);
// }
// }
// rs.close();
// DatabaseConnection.closeStatement(stmt);
// DatabaseConnection.closeStatement(insertStmt);
// }
// }
// // update the jam_topic.current_version_id field that we had to leave blank
// on initial insert
// String updateSql =
// "UPDATE jam_topic SET current_version_id = ? WHERE topic_id = ?";
// logger.info(updateSql);
// PreparedStatement update = conn.prepareStatement(updateSql);
// for (Integer topicId : topicVersions.keySet()) {
// Integer topicVersionId = topicVersions.get(topicId);
// update.setObject(1, topicVersionId);
// update.setObject(2, topicId);
// update.executeUpdate();
// }
// } catch (Exception e) {
// logger.severe("Error attempting to migrate the database", e);
// errors.add(new WikiMessage("error.unknown", e.getMessage()));
// try {
// newQueryHandler.dropTables(conn);
// } catch (Exception ex) {
// logger.warning("Unable to drop tables in NEW database following failed migration",
// ex);
// }
// } finally {
// if (conn != null) {
// try {
// conn.close();
// } catch (SQLException e) {}
// }
// if (from != null) {
// DatabaseConnection.closeConnection(from, stmt, rs);
// }
// }
// }
//
// /**
// *
// */
// protected static String getConnectionValidationQuery() {
// return (!StringUtils.isBlank(CONNECTION_VALIDATION_QUERY)) ?
// CONNECTION_VALIDATION_QUERY : null;
// }
//
// /**
// *
// */
// protected static String getExistenceValidationQuery() {
// return (!StringUtils.isBlank(EXISTENCE_VALIDATION_QUERY)) ?
// EXISTENCE_VALIDATION_QUERY : null;
// }
/**
*
*/
public synchronized static void initialize() {
try {
OS.initialize();
// WikiDatabase.CONNECTION_VALIDATION_QUERY =
// WikiDatabase.queryHandler().connectionValidationQuery();
// WikiDatabase.EXISTENCE_VALIDATION_QUERY =
// WikiDatabase.queryHandler().existenceValidationQuery();
// // initialize connection pool in its own try-catch to avoid an error
// // causing property values not to be saved.
// // this clears out any existing connection pool, so that a new one will
// be created on first access
// DatabaseConnection.closeConnectionPool();
} catch (Exception e) {
logger.severe("Unable to initialize database", e);
}
}
/**
*
*/
// private static Connection initializeNewDatabase(Properties props,
// List<WikiMessage> errors, QueryHandler newQueryHandler) {
// String driver = props.getProperty(Environment.PROP_DB_DRIVER);
// String url = props.getProperty(Environment.PROP_DB_URL);
// String userName = props.getProperty(Environment.PROP_DB_USERNAME);
// String password =
// Encryption.getEncryptedProperty(Environment.PROP_DB_PASSWORD, props);
// Connection conn = null;
// try {
// // test to see if we can connect to the new database
// conn = DatabaseConnection.getTestConnection(driver, url, userName,
// password);
// conn.setAutoCommit(true);
// } catch (Exception e) {
// if (conn != null) {
// try {
// conn.close();
// } catch (SQLException ex) {}
// }
// errors.add(new WikiMessage("error.databaseconnection", e.getMessage()));
// return null;
// }
// // test to see if JAMWiki tables already exist (if they do, we can't
// continue this migration process
// Statement stmt = null;
// try {
// stmt = conn.createStatement();
// stmt.executeQuery(newQueryHandler.existenceValidationQuery());
// errors.add(new WikiMessage("setup.error.migrate"));
// if (conn != null) {
// try {
// conn.close();
// } catch (SQLException ex) {}
// }
// return null;
// } catch (Exception ex) {
// // we expect this exception as the JAMWiki tables don't exist
// logger.fine("NEW Database does not contain any JAMWiki instance");
// } finally {
// DatabaseConnection.closeStatement(stmt);
// }
// try {
// newQueryHandler.createTables(conn);
// } catch (Exception e) {
// logger.severe("Error attempting to migrate the database", e);
// errors.add(new WikiMessage("error.unknown", e.getMessage()));
// try {
// newQueryHandler.dropTables(conn);
// } catch (Exception ex) {
// logger.warning("Unable to drop tables in NEW database following failed migration",
// ex);
// }
// if (conn != null) {
// try {
// conn.close();
// } catch (SQLException ex) {}
// }
// }
// return conn;
// }
public synchronized static void shutdown() {
// try {
// DatabaseConnection.closeConnectionPool();
// } catch (Exception e) {
// logger.severe("Unable to close the connection pool on shutdown", e);
// }
}
// /**
// * This method causes all existing data to be deleted from the Wiki. Use
// only
// * when totally re-initializing a system. To reiterate: CALLING THIS METHOD
// WILL
// * DELETE ALL WIKI DATA!
// */
// protected static void purgeData(Connection conn) throws DataAccessException
// {
// // BOOM! Everything gone...
// WikiDatabase.queryHandler().dropTables(conn);
// try {
// // re-create empty tables
// WikiDatabase.queryHandler().createTables(conn);
// } catch (Exception e) {
// // creation failure, don't leave tables half-committed
// WikiDatabase.queryHandler().dropTables(conn);
// }
// }
//
// /**
// *
// */
// protected static QueryHandler queryHandler() throws DataAccessException {
// // FIXME - this is ugly
// if (WikiBase.getDataHandler() instanceof AnsiDataHandler) {
// AnsiDataHandler dataHandler = (AnsiDataHandler)WikiBase.getDataHandler();
// return dataHandler.queryHandler();
// }
// throw new DataAccessException("Unable to determine query handler");
// }
//
// /**
// *
// */
// protected static void releaseConnection(Connection conn, Object
// transactionObject) throws SQLException {
// if (transactionObject instanceof Connection) {
// // transaction objects will be released elsewhere
// return;
// }
// WikiDatabase.releaseConnection(conn);
// }
//
// /**
// *
// */
// private static void releaseConnection(Connection conn) throws SQLException
// {
// if (conn == null) {
// return;
// }
// try {
// conn.commit();
// } finally {
// DatabaseConnection.closeConnection(conn);
// }
// }
//
// /**
// * Return the largest primary key ID for the specified table, or 1 if the
// table does
// * not have a numeric primary key value.
// */
// private static int retrieveMaximumTableId(String tableName, String
// primaryIdColumnName) throws SQLException {
// if (StringUtils.isBlank(tableName) ||
// StringUtils.isBlank(primaryIdColumnName)) {
// return 1;
// }
// String sql = "select max(" + primaryIdColumnName +
// ") as max_table_id from " + tableName;
// Connection conn = null;
// Statement stmt = null;
// ResultSet rs = null;
// try {
// conn = DatabaseConnection.getConnection();
// stmt = conn.createStatement();
// rs = stmt.executeQuery(sql);
// return (rs.next()) ? rs.getInt("max_table_id") : 0;
// } finally {
// DatabaseConnection.closeConnection(conn, stmt, rs);
// }
// }
// private Topic setupSpecialWikiTopics(WikiUser wikiUser, Locale locale,
// String topicName) {
// String contents = null;
// try {
// contents = BlikiUtil.readSpecialPage(locale, topicName);
// if (contents != null) {
// Topic page = new Topic(topicName, contents, wikiUser);
// page = PageService.save(page, null);
// return page;
//
// }
// } catch (IOException e) {
// }
// return null;
// }
/**
*
*/
public static void setup(Locale locale, WikiUser user, String username,
String encryptedPassword) throws DataAccessException, WikiException {
TransactionStatus status = null;
try {
// set up tables
WikiDatabase.setupDefaultVirtualWiki();
WikiDatabase.setupRoles();
WikiDatabase.setupGroups();
WikiDatabase.setupAdminUser(user, username, encryptedPassword);
WikiDatabase.setupSpecialPages(locale, user);
} catch (DataAccessException e) {
// DatabaseConnection.rollbackOnException(status, e);
logger.severe("Unable to set up database tables", e);
// clean up anything that might have been created
// try {
// Connection conn = DatabaseConnection.getConnection();
// WikiDatabase.queryHandler().dropTables(conn);
// } catch (Exception e2) {}
throw e;
} catch (WikiException e) {
// DatabaseConnection.rollbackOnException(status, e);
logger.severe("Unable to set up database tables", e);
// clean up anything that might have been created
// try {
// Connection conn = DatabaseConnection.getConnection();
// WikiDatabase.queryHandler().dropTables(conn);
// } catch (Exception e2) {}
throw e;
}
// DatabaseConnection.commit(status);
}
/**
*
*/
private static void setupAdminUser(WikiUser user, String username,
String encryptedPassword) throws DataAccessException, WikiException {
if (user == null) {
throw new IllegalArgumentException(
"Cannot pass null or anonymous WikiUser object to setupAdminUser");
}
if (WikiBase.getDataHandler().lookupWikiUser(user.getUsername()) != null) {
logger.warning("Admin user already exists");
}
WikiBase.getDataHandler().writeWikiUser(user, username, encryptedPassword);
List<String> roles = new ArrayList<String>();
roles.add(RoleImpl.ROLE_ADMIN.getAuthority());
roles.add(RoleImpl.ROLE_IMPORT.getAuthority());
roles.add(RoleImpl.ROLE_SYSADMIN.getAuthority());
roles.add(RoleImpl.ROLE_TRANSLATE.getAuthority());
WikiBase.getDataHandler().writeRoleMapUser(user.getUsername(), roles);
}
// /**
// *
// */
// public static void setupDefaultDatabase(Properties props) {
// props.setProperty(Environment.PROP_DB_DRIVER, "org.hsqldb.jdbcDriver");
// props.setProperty(Environment.PROP_DB_TYPE, DataHandler.DATA_HANDLER_HSQL);
// props.setProperty(Environment.PROP_DB_USERNAME, "sa");
// props.setProperty(Environment.PROP_DB_PASSWORD, "");
// File file = new File(props.getProperty(Environment.PROP_BASE_FILE_DIR),
// "database");
// if (!file.exists()) {
// file.mkdirs();
// }
// String url = "jdbc:hsqldb:file:" + new File(file.getPath(),
// "jamwiki").getPath() + ";shutdown=true";
// props.setProperty(Environment.PROP_DB_URL, url);
// }
/**
*
*/
private static void setupDefaultVirtualWiki() throws DataAccessException,
WikiException {
VirtualWiki virtualWiki = new VirtualWiki();
virtualWiki.setName(WikiBase.DEFAULT_VWIKI);
virtualWiki.setDefaultTopicName(Environment
.getValue(Environment.PROP_BASE_DEFAULT_TOPIC));
WikiBase.getDataHandler().writeVirtualWiki(virtualWiki);
}
/**
*
*/
protected static void setupGroups() throws DataAccessException, WikiException {
WikiGroup group = new WikiGroup();
group.setName(WikiGroup.GROUP_ANONYMOUS);
// FIXME - use message key
group
.setDescription("All non-logged in users are automatically assigned to the anonymous group.");
WikiBase.getDataHandler().writeWikiGroup(group);
List<String> anonymousRoles = new ArrayList<String>();
anonymousRoles.add(RoleImpl.ROLE_EDIT_EXISTING.getAuthority());
anonymousRoles.add(RoleImpl.ROLE_EDIT_NEW.getAuthority());
anonymousRoles.add(RoleImpl.ROLE_UPLOAD.getAuthority());
anonymousRoles.add(RoleImpl.ROLE_VIEW.getAuthority());
WikiBase.getDataHandler().writeRoleMapGroup(group.getGroupId(),
group.getName(), anonymousRoles);
group = new WikiGroup();
group.setName(WikiGroup.GROUP_REGISTERED_USER);
// FIXME - use message key
group
.setDescription("All logged in users are automatically assigned to the registered user group.");
WikiBase.getDataHandler().writeWikiGroup(group);
List<String> userRoles = new ArrayList<String>();
userRoles.add(RoleImpl.ROLE_EDIT_EXISTING.getAuthority());
userRoles.add(RoleImpl.ROLE_EDIT_NEW.getAuthority());
userRoles.add(RoleImpl.ROLE_MOVE.getAuthority());
userRoles.add(RoleImpl.ROLE_UPLOAD.getAuthority());
userRoles.add(RoleImpl.ROLE_VIEW.getAuthority());
WikiBase.getDataHandler().writeRoleMapGroup(group.getGroupId(),
group.getName(), userRoles);
}
/**
*
*/
protected static void setupRoles() throws DataAccessException, WikiException {
Role role = RoleImpl.ROLE_ADMIN;
// FIXME - use message key
role
.setDescription("Provides the ability to perform wiki maintenance tasks not available to normal users.");
WikiBase.getDataHandler().writeRole(role, false);
role = RoleImpl.ROLE_EDIT_EXISTING;
// FIXME - use message key
role.setDescription("Allows a user to edit an existing topic.");
WikiBase.getDataHandler().writeRole(role, false);
role = RoleImpl.ROLE_EDIT_NEW;
// FIXME - use message key
role.setDescription("Allows a user to create a new topic.");
WikiBase.getDataHandler().writeRole(role, false);
role = RoleImpl.ROLE_IMPORT;
// FIXME - use message key
role.setDescription("Allows a user to import data from a file.");
WikiBase.getDataHandler().writeRole(role, false);
role = RoleImpl.ROLE_MOVE;
// FIXME - use message key
role.setDescription("Allows a user to move a topic to a different name.");
WikiBase.getDataHandler().writeRole(role, false);
role = RoleImpl.ROLE_SYSADMIN;
// FIXME - use message key
role
.setDescription("Allows access to set database parameters, modify parser settings, and set other wiki system settings.");
WikiBase.getDataHandler().writeRole(role, false);
role = RoleImpl.ROLE_TRANSLATE;
// FIXME - use message key
role
.setDescription("Allows access to the translation tool used for modifying the values of message keys used to display text on the wiki.");
WikiBase.getDataHandler().writeRole(role, false);
role = RoleImpl.ROLE_UPLOAD;
// FIXME - use message key
role.setDescription("Allows a user to upload a file to the wiki.");
WikiBase.getDataHandler().writeRole(role, false);
role = RoleImpl.ROLE_VIEW;
// FIXME - use message key
role.setDescription("Allows a user to view topics on the wiki.");
WikiBase.getDataHandler().writeRole(role, false);
}
/**
*
*/
protected static void setupSpecialPage(Locale locale, String virtualWiki,
String topicName, WikiUser user, boolean adminOnly)
throws DataAccessException, WikiException {
logger.info("Setting up special page " + virtualWiki + " / " + topicName);
if (user == null) {
throw new IllegalArgumentException(
"Cannot pass null WikiUser object to setupSpecialPage");
}
String contents = null;
try {
contents = WikiUtil.readSpecialPage(locale, topicName);
} catch (IOException e) {
throw new DataAccessException(e);
}
Topic topic = new Topic();
topic.setName(topicName);
topic.setVirtualWiki(virtualWiki);
topic.setTopicContent(contents);
topic.setAdminOnly(adminOnly);
int charactersChanged = StringUtils.length(contents);
// FIXME - hard coding
TopicVersion topicVersion = new TopicVersion(user, user
.getLastLoginIpAddress(), "Automatically created by system setup",
contents, charactersChanged);
// FIXME - it is not connection-safe to parse for metadata since we are
// already holding a connection
// ParserOutput parserOutput =
// ParserUtil.parserOutput(topic.getTopicContent(), virtualWiki, topicName);
// WikiBase.getDataHandler().writeTopic(topic, topicVersion,
// parserOutput.getCategories(), parserOutput.getLinks());
WikiBase.getDataHandler().writeTopic(topic, topicVersion, null, null);
}
/**
*
*/
private static void setupSpecialPages(Locale locale, WikiUser user)
throws DataAccessException, WikiException {
List<VirtualWiki> all = WikiBase.getDataHandler().getVirtualWikiList();
for (VirtualWiki virtualWiki : all) {
// create the default topics
setupSpecialPage(locale, virtualWiki.getName(),
WikiBase.SPECIAL_PAGE_STARTING_POINTS, user, false);
setupSpecialPage(locale, virtualWiki.getName(),
WikiBase.SPECIAL_PAGE_LEFT_MENU, user, true);
setupSpecialPage(locale, virtualWiki.getName(),
WikiBase.SPECIAL_PAGE_BOTTOM_AREA, user, true);
setupSpecialPage(locale, virtualWiki.getName(),
WikiBase.SPECIAL_PAGE_STYLESHEET, user, true);
}
}
}