/**
* Rename file using prefix and suffix settings.
*
* @param path the path to rename
*/
protected void renameFile(Path path) {
// bail out if there's no in-writing settings
if (!StringUtils.hasText(prefix) && !StringUtils.hasText(suffix)) {
return;
}
String name = path.getName();
if (StringUtils.startsWithIgnoreCase(name, prefix)) {
name = name.substring(prefix.length());
}
if (StringUtils.endsWithIgnoreCase(name, suffix)) {
name = name.substring(0, name.length() - suffix.length());
}
Path toPath = new Path(path.getParent(), name);
try {
FileSystem fs = path.getFileSystem(getConfiguration());
if (!fs.rename(path, toPath)) {
throw new StoreException(
"Failed renaming from "
+ path
+ " to "
+ toPath
+ " with configuration "
+ getConfiguration());
}
} catch (IOException e) {
log.error("Error renaming file", e);
throw new StoreException("Error renaming file", e);
}
}
/**
* Return the path within the web application for the given request.
*
* <p>Detects include request URL if called within a RequestDispatcher include.
*
* @param request current HTTP request
* @return the path within the web application
*/
public String getPathWithinApplication(HttpServletRequest request) {
String contextPath = getContextPath(request);
String requestUri = getRequestUri(request);
if (StringUtils.startsWithIgnoreCase(requestUri, contextPath)) {
// Normal case: URI contains context path.
String path = requestUri.substring(contextPath.length());
return (StringUtils.hasText(path) ? path : "/");
} else {
// Special case: rather unusual.
return requestUri;
}
}
protected boolean canUseExistingTMSessionObject(String awardNumber) {
String sessionObjectKey =
GlobalVariables.getUserSession().getKualiSessionId()
+ Constants.TIME_AND_MONEY_DOCUMENT_STRING_FOR_SESSION;
String prefix = null;
TimeAndMoneyDocument tmDocFromSession =
(TimeAndMoneyDocument) GlobalVariables.getUserSession().retrieveObject(sessionObjectKey);
if (tmDocFromSession == null) {
return false;
}
Map<String, AwardHierarchyNode> tmpNodes = tmDocFromSession.getAwardHierarchyNodes();
if (tmpNodes != null && CollectionUtils.isNotEmpty(tmpNodes.keySet())) {
for (String tempAwardNumber : tmpNodes.keySet()) {
prefix = tempAwardNumber.substring(0, tempAwardNumber.indexOf("-"));
if (!StringUtils.startsWithIgnoreCase(awardNumber, prefix)) {
return false;
}
}
}
return true;
}
/**
* Set the prefix used in mappings.
*
* @param prefix the prefix
*/
public void setPrefix(String prefix) {
Assert.isTrue(
"".equals(prefix) || StringUtils.startsWithIgnoreCase(prefix, "/"),
"prefix must start with '/'");
this.prefix = prefix;
}
/**
* Execute the given SQL script.
*
* <p>Statement separators and comments will be removed before executing individual statements
* within the supplied script.
*
* <p><b>Do not use this method to execute DDL if you expect rollback.</b>
*
* @param connection the JDBC connection to use to execute the script; already configured and
* ready to use
* @param resource the resource (potentially associated with a specific encoding) to load the SQL
* script from
* @param continueOnError whether or not to continue without throwing an exception in the event of
* an error
* @param ignoreFailedDrops whether or not to continue in the event of specifically an error on a
* {@code DROP} statement
* @param commentPrefix the prefix that identifies comments in the SQL script — typically
* "--"
* @param separator the script statement separator; defaults to {@value
* #DEFAULT_STATEMENT_SEPARATOR} if not specified
* @param blockCommentStartDelimiter the <em>start</em> block comment delimiter; never {@code
* null} or empty
* @param blockCommentEndDelimiter the <em>end</em> block comment delimiter; never {@code null} or
* empty
*/
public static void executeSqlScript(
Connection connection,
EncodedResource resource,
boolean continueOnError,
boolean ignoreFailedDrops,
String commentPrefix,
String separator,
String blockCommentStartDelimiter,
String blockCommentEndDelimiter)
throws SQLException, ScriptException {
if (logger.isInfoEnabled()) {
logger.info("Executing SQL script from " + resource);
}
long startTime = System.currentTimeMillis();
List<String> statements = new LinkedList<String>();
String script;
try {
script = readScript(resource, commentPrefix, separator);
} catch (IOException ex) {
throw new CannotReadScriptException(resource, ex);
}
if (separator == null) {
separator = DEFAULT_STATEMENT_SEPARATOR;
if (!containsSqlScriptDelimiters(script, separator)) {
separator = "\n";
}
}
splitSqlScript(
resource,
script,
separator,
commentPrefix,
blockCommentStartDelimiter,
blockCommentEndDelimiter,
statements);
int lineNumber = 0;
Statement stmt = connection.createStatement();
try {
for (String statement : statements) {
lineNumber++;
try {
stmt.execute(statement);
int rowsAffected = stmt.getUpdateCount();
if (logger.isDebugEnabled()) {
logger.debug(rowsAffected + " returned as updateCount for SQL: " + statement);
}
} catch (SQLException ex) {
boolean dropStatement = StringUtils.startsWithIgnoreCase(statement.trim(), "drop");
if (continueOnError || (dropStatement && ignoreFailedDrops)) {
if (logger.isDebugEnabled()) {
logger.debug(
"Failed to execute SQL script statement at line "
+ lineNumber
+ " of resource "
+ resource
+ ": "
+ statement,
ex);
}
} else {
throw new ScriptStatementFailedException(statement, lineNumber, resource, ex);
}
}
}
} finally {
try {
stmt.close();
} catch (Throwable ex) {
logger.debug("Could not close JDBC Statement", ex);
}
}
long elapsedTime = System.currentTimeMillis() - startTime;
if (logger.isInfoEnabled()) {
logger.info("Executed SQL script from " + resource + " in " + elapsedTime + " ms.");
}
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws IOException {
HttpSession session = request.getSession();
boolean redirect = false;
if (session != null) {
SecurityContext context = (SecurityContext) session.getAttribute("SPRING_SECURITY_CONTEXT");
if (context != null) {
if (context.getAuthentication() != null
&& context.getAuthentication().getPrincipal() != null
&& context.getAuthentication().getPrincipal() instanceof User) {
User user = userService.getUserFromSecurityContext();
String servletPath = request.getServletPath();
if (!servletPath.startsWith("/auth")
&& !servletPath.startsWith("/resources")
&& user != null) {
boolean skipValidation = false;
if (user.isPasswordExpired()
&& !servletPath.startsWith("/profile/changePassword")
&& !servletPath.startsWith("/auth/forgotPassword")) {
response.sendRedirect(request.getContextPath() + "/profile/changePassword");
skipValidation = true;
redirect = true;
} else if (user.isPasswordExpired()
&& (servletPath.startsWith("/profile/changePassword")
|| servletPath.startsWith("/auth/forgotPassword"))) {
skipValidation = true;
}
if (!user.isActivated() && !servletPath.startsWith("/activate") && !skipValidation) {
response.sendRedirect(request.getContextPath() + "/activate");
redirect = true;
}
}
}
}
}
// We do not want the healthcheck to ever populate the WebRequest object
if (request != null
&& !StringUtils.startsWithIgnoreCase(request.getServletPath(), "/healthcheck")) {
String serverName;
// If ApplicationDomain is set on the properties then use that as the server name, else use
// what came off the request
if (StringUtils.hasText(applicationDomain)
&& !("${" + SystemProperties.APPLICATION_DOMAIN + "}")
.equalsIgnoreCase(applicationDomain)) {
serverName = applicationDomain;
} else {
serverName = request.getServerName();
}
WebRequest.getInstance(
request.getScheme(), serverName, request.getServerPort(), request.getContextPath());
}
if (redirect) {
return false;
}
return true;
}
/**
* Check whether the specified path indicates a resource in the protected WEB-INF or META-INF
* directories.
*
* @param path the path to check
*/
private static boolean isProtectedResource(String path) {
return (StringUtils.startsWithIgnoreCase(path, "/WEB-INF")
|| StringUtils.startsWithIgnoreCase(path, "/META-INF"));
}