private void saveToDb() {
Connection con = null;
PreparedStatement pstmt = null;
try {
con = DbConnectionManager.getConnection();
pstmt = con.prepareStatement(UPDATE_WARE);
System.out.println(UPDATE_WARE);
pstmt.setString(1, StringUtils.toChinese(this.Pname));
pstmt.setString(2, StringUtils.toChinese(this.Pmodel));
pstmt.setString(3, StringUtils.toChinese(this.Pcost));
pstmt.setString(4, StringUtils.toChinese(this.Pheft));
pstmt.setString(5, StringUtils.toChinese(this.Pfacturer));
pstmt.setString(6, StringUtils.toChinese(this.Pnote));
pstmt.setInt(7, this.Status);
pstmt.setInt(8, this.Id);
pstmt.executeUpdate();
} catch (SQLException sqle) {
System.err.println("错误位置: DbWare.java:saveToDb(): " + sqle);
sqle.printStackTrace();
} finally {
try {
pstmt.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
con.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public Collection<User> findUsers(Set<String> fields, String query)
throws UnsupportedOperationException {
if (fields.isEmpty()) {
return Collections.emptyList();
}
if (!getSearchFields().containsAll(fields)) {
throw new IllegalArgumentException("Search fields " + fields + " are not valid.");
}
if (query == null || "".equals(query)) {
return Collections.emptyList();
}
// SQL LIKE queries don't map directly into a keyword/wildcard search like we want.
// Therefore, we do a best approximiation by replacing '*' with '%' and then
// surrounding the whole query with two '%'. This will return more data than desired,
// but is better than returning less data than desired.
query = "%" + query.replace('*', '%') + "%";
if (query.endsWith("%%")) {
query = query.substring(0, query.length() - 1);
}
List<String> usernames = new ArrayList<String>(50);
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
try {
con = DbConnectionManager.getConnection();
stmt = con.createStatement();
StringBuilder sql = new StringBuilder();
sql.append("SELECT username FROM jiveUser WHERE");
boolean first = true;
if (fields.contains("Username")) {
sql.append(" username LIKE '").append(StringUtils.escapeForSQL(query)).append("'");
first = false;
}
if (fields.contains("Name")) {
if (!first) {
sql.append(" AND");
}
sql.append(" name LIKE '").append(StringUtils.escapeForSQL(query)).append("'");
first = false;
}
if (fields.contains("Email")) {
if (!first) {
sql.append(" AND");
}
sql.append(" email LIKE '").append(StringUtils.escapeForSQL(query)).append("'");
}
rs = stmt.executeQuery(sql.toString());
while (rs.next()) {
usernames.add(rs.getString(1));
}
} catch (SQLException e) {
Log.error(e);
} finally {
DbConnectionManager.closeConnection(rs, stmt, con);
}
return new UserCollection(usernames.toArray(new String[usernames.size()]));
}
/**
* Initialize the event queue.
*
* @param props A container of configuration properties.
* @exception FrameworkException Thrown if configuration is invalid.
*/
public void initialize(Map props) throws FrameworkException {
String temp = (String) props.get(LOAD_EVENT_BATCH_SIZE_PROP);
if (StringUtils.hasValue(temp)) {
maxDatabaseEventLoadSize = StringUtils.getInteger(temp);
if (Debug.isLevelEnabled(Debug.SYSTEM_CONFIG))
Debug.log(
Debug.SYSTEM_CONFIG,
"QUEUE OPERATION: Initializing: Maximum-database-event-batch-load-size is ["
+ maxDatabaseEventLoadSize
+ "] rows.");
}
}
private void insertIntoDb() {
Connection con = null;
PreparedStatement pstmt = null;
try {
con = DbConnectionManager.getConnection();
pstmt = con.prepareStatement(INSERT_WARE);
pstmt.setInt(1, this.Id);
pstmt.setString(2, StringUtils.toChinese(this.Pname));
pstmt.setString(3, StringUtils.toChinese(this.Pmodel));
pstmt.setString(4, StringUtils.toChinese(this.Pcost));
pstmt.setString(5, StringUtils.toChinese(this.Pheft));
pstmt.setString(6, StringUtils.toChinese(this.Pfacturer));
pstmt.setString(7, StringUtils.toChinese(this.Pnote));
pstmt.setString(8, StringUtils.toChinese(this.Createdate));
pstmt.setInt(9, this.Status);
pstmt.executeUpdate();
} catch (SQLException sqle) {
System.err.println("错误位置: Dbware:insertIntoDb()-" + sqle);
sqle.printStackTrace();
} finally {
try {
pstmt.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
con.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/** Constructor. */
public DatabaseEventQueue() {
if (Debug.isLevelEnabled(Debug.OBJECT_LIFECYCLE))
Debug.log(
Debug.OBJECT_LIFECYCLE,
"QUEUE OPERATION: Creating event queue of type ["
+ StringUtils.getClassName(this)
+ "] ...");
queue = Collections.synchronizedList(new LinkedList());
}
/**
* Get a human-readable description of the event queue.
*
* @return A description of the event queue.
*/
public String describe() {
StringBuffer sb = new StringBuffer();
sb.append("Database event queue [");
sb.append(StringUtils.getClassName(this));
sb.append("], in-memory-event-count [");
sb.append(queue.size());
sb.append("], Event-load-batch-size [");
sb.append(maxDatabaseEventLoadSize);
sb.append("]");
return (sb.toString());
}
public void addRioxxVersionSection(List upload, Item item) throws WingException {
String version = item.getMetadata("rioxxterms.version");
if (StringUtils.isNotBlank(version) && !"NA".equals(version)) {
try {
DCInputsReader a = new DCInputsReader();
java.util.List<String> pairs = a.getPairs("rioxxterms_version");
int humanReadable = pairs.indexOf(version) - 1;
version = pairs.get(humanReadable);
} catch (DCInputsReaderException e) {
log.error(e.getMessage(), e);
}
upload
.addItem("upload-rioxx-version-warning", "upload-rioxx-version-warning")
.addContent(T_rioxx_version.parameterize(version));
}
}
public void setCreationDate(String username, Date creationDate) throws UserNotFoundException {
if (isReadOnly()) {
// Reject the operation since the provider is read-only
throw new UnsupportedOperationException();
}
Connection con = null;
PreparedStatement pstmt = null;
try {
con = DbConnectionManager.getConnection();
pstmt = con.prepareStatement(UPDATE_CREATION_DATE);
pstmt.setString(1, StringUtils.dateToMillis(creationDate));
pstmt.setString(2, username);
pstmt.executeUpdate();
} catch (SQLException sqle) {
throw new UserNotFoundException(sqle);
} finally {
DbConnectionManager.closeConnection(pstmt, con);
}
}
public User createUser(String username, String password, String name, String email)
throws UserAlreadyExistsException {
if (isReadOnly()) {
// Reject the operation since the provider is read-only
throw new UnsupportedOperationException();
}
try {
loadUser(username);
// The user already exists since no exception, so:
throw new UserAlreadyExistsException("Username " + username + " already exists");
} catch (UserNotFoundException unfe) {
// The user doesn't already exist so we can create a new user
// Determine if the password should be stored as plain text or encrypted.
boolean usePlainPassword = JiveGlobals.getBooleanProperty("user.usePlainPassword");
String encryptedPassword = null;
if (!usePlainPassword) {
try {
encryptedPassword = AuthFactory.encryptPassword(password);
// Set password to null so that it's inserted that way.
password = null;
} catch (UnsupportedOperationException uoe) {
// Encrypting the password may have failed if in setup mode. Therefore,
// use the plain password.
}
}
Date now = new Date();
Connection con = null;
PreparedStatement pstmt = null;
try {
con = DbConnectionManager.getConnection();
pstmt = con.prepareStatement(INSERT_USER);
pstmt.setString(1, username);
if (password == null) {
pstmt.setNull(2, Types.VARCHAR);
} else {
pstmt.setString(2, password);
}
if (encryptedPassword == null) {
pstmt.setNull(3, Types.VARCHAR);
} else {
pstmt.setString(3, encryptedPassword);
}
if (name == null) {
pstmt.setNull(4, Types.VARCHAR);
} else {
pstmt.setString(4, name);
}
if (email == null) {
pstmt.setNull(5, Types.VARCHAR);
} else {
pstmt.setString(5, email);
}
pstmt.setString(6, StringUtils.dateToMillis(now));
pstmt.setString(7, StringUtils.dateToMillis(now));
pstmt.execute();
} catch (Exception e) {
Log.error(LocaleUtils.getLocalizedString("admin.error"), e);
} finally {
DbConnectionManager.closeConnection(pstmt, con);
}
return new User(username, name, email, now, now);
}
}
/**
* Reset any events meeting the given criteria so that they can be retried.
*
* @param criteria An event containing the event-selection criteria.
* @return The number of events reset.
* @exception FrameworkException Thrown on errors.
*/
protected static int reset(Event criteria) throws FrameworkException {
Debug.log(
Debug.MSG_STATUS, "QUEUE OPERATION: Resetting events in database for database queue ...");
if (!StringUtils.hasValue(criteria.channelName)) {
throw new FrameworkException(
"ERROR: Event channel name is a required queue search criteria.");
}
Connection dbConn = null;
PreparedStatement ps = null;
long startTime = -1;
if (Debug.isLevelEnabled(Debug.BENCHMARK)) startTime = System.currentTimeMillis();
try {
dbConn = DBConnectionPool.getInstance().acquireConnection();
if (Debug.isLevelEnabled(Debug.DB_DATA))
Debug.log(
Debug.DB_DATA, "Criteria used to reset events in database:\n" + criteria.describe());
// If no identifier was given that uniquely identifies a single event ...
if (criteria.id == 0) {
// Use last error time and error count, if available.
if (Debug.isLevelEnabled(Debug.DB_DATA))
Debug.log(Debug.DB_DATA, "\n" + LINE + "\nExecuting SQL:\n" + UPDATE_EVENT_RETRY_SQL);
ps = dbConn.prepareStatement(UPDATE_EVENT_RETRY_SQL);
ps.setString(1, criteria.channelName);
if (criteria.lastErrorTime == null) ps.setNull(2, Types.DATE);
else ps.setTimestamp(2, criteria.lastErrorTime);
if (criteria.errorCount < 1) ps.setNull(3, Types.INTEGER);
else ps.setInt(3, criteria.errorCount);
} else {
// An Id was given which should uniquely identify a single event, so we should
// skip using any other qualifying criteria, if present.
if (Debug.isLevelEnabled(Debug.DB_DATA))
Debug.log(
Debug.DB_DATA, "\n" + LINE + "\nExecuting SQL:\n" + UPDATE_EVENT_RETRY_BY_ID_SQL);
ps = dbConn.prepareStatement(UPDATE_EVENT_RETRY_BY_ID_SQL);
ps.setString(1, criteria.channelName);
ps.setInt(2, criteria.id);
}
int numRows = ps.executeUpdate();
DBConnectionPool.getInstance().commit(dbConn);
if (Debug.isLevelEnabled(Debug.DB_DATA))
Debug.log(
Debug.DB_DATA, "Committed SQL execution affected [" + numRows + "] rows.\n" + LINE);
return numRows;
} catch (SQLException sqle) {
throw new DatabaseException(
"ERROR: Could not execute SQL statement:\n" + DBInterface.getSQLErrorMessage(sqle));
} catch (Exception e) {
throw new DatabaseException("ERROR: Could not execute SQL statement:\n" + e.toString());
} finally {
releaseDatabaseResources(dbConn, ps);
if (Debug.isLevelEnabled(Debug.BENCHMARK) && (startTime > 0)) {
long stopTime = System.currentTimeMillis();
Debug.log(
Debug.BENCHMARK,
"ELAPSED TIME ["
+ (stopTime - startTime)
+ "] msec: "
+ "SQL: Time to reset event(s) in PersistentEvent database table.");
}
}
}
/**
* Load any available events from the database up to the configured maximum.
*
* @param criteria An event containing the event-selection criteria.
* @return The next available event on the queue.
* @exception FrameworkException Thrown on errors.
*/
private void loadFromDatabase(Event criteria) throws FrameworkException {
Debug.log(Debug.MSG_STATUS, "QUEUE OPERATION: Loading events from database into queue ...");
if (!StringUtils.hasValue(criteria.channelName)) {
throw new FrameworkException(
"ERROR: Event channel name is a required queue search criteria.");
}
Connection dbConn = null;
PreparedStatement ps = null;
long startTime = -1;
if (Debug.isLevelEnabled(Debug.BENCHMARK)) startTime = System.currentTimeMillis();
try {
dbConn = DBConnectionPool.getInstance().acquireConnection();
if (Debug.isLevelEnabled(Debug.DB_DATA))
Debug.log(Debug.DB_DATA, "\n" + LINE + "\nExecuting SQL:\n" + QUERY_EVENT_SQL);
if (Debug.isLevelEnabled(Debug.DB_DATA))
Debug.log(
Debug.DB_DATA, "Criteria used in query against database:\n" + criteria.describe());
ps = dbConn.prepareStatement(QUERY_EVENT_SQL);
ps.setString(1, criteria.channelName);
ResultSet rs = ps.executeQuery();
for (int counter = 0; (counter < maxDatabaseEventLoadSize) && rs.next(); counter++) {
Event event = new Event();
event.channelName = rs.getString(CHANNEL_NAME_COL);
event.id = rs.getInt(ID_COL);
event.message = DBLOBUtils.getCLOB(rs, MESSAGE_COL);
if (Debug.isLevelEnabled(Debug.MSG_LIFECYCLE))
Debug.log(Debug.MSG_LIFECYCLE, "Event contents:\n" + event.message);
event.arrivalTime = rs.getTimestamp(ARRIVAL_TIME_COL);
event.errorStatus = rs.getString(ERROR_STATUS_COL);
event.errorCount = rs.getInt(ERROR_COUNT_COL);
event.lastErrorMessage = rs.getString(LAST_ERROR_MESSAGE_COL);
event.lastErrorTime = rs.getTimestamp(LAST_ERROR_TIME_COL);
// Add item to in-memory buffer.
if (Debug.isLevelEnabled(Debug.MSG_STATUS))
Debug.log(
Debug.MSG_STATUS,
"Adding event [" + event.describe() + "] to in-memory queue buffer.");
queue.add(event);
if (Debug.isLevelEnabled(Debug.MSG_STATUS))
Debug.log(Debug.MSG_STATUS, "In-memory queue buffer size [" + queue.size() + "].");
}
if (Debug.isLevelEnabled(Debug.DB_DATA)) Debug.log(Debug.DB_DATA, "\n" + LINE);
} catch (SQLException sqle) {
throw new DatabaseException(
"ERROR: Could not execute SQL statement:\n" + DBInterface.getSQLErrorMessage(sqle));
} catch (Exception e) {
throw new DatabaseException("ERROR: Could not execute SQL statement:\n" + e.toString());
} finally {
releaseDatabaseResources(dbConn, ps);
if (Debug.isLevelEnabled(Debug.BENCHMARK) && (startTime > 0)) {
long stopTime = System.currentTimeMillis();
Debug.log(
Debug.BENCHMARK,
"ELAPSED TIME ["
+ (stopTime - startTime)
+ "] msec: "
+ "SQL: Time to load event(s) from PersistentEvent database table.");
}
}
}