Example usage for org.apache.commons.lang StringUtils substringAfter

List of usage examples for org.apache.commons.lang StringUtils substringAfter

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.lang.*
  5. StringUtils
  6. substringAfter

Introduction

In this page you can find the example usage for org.apache.commons.lang StringUtils substringAfter.

Prototype

public static String substringAfter(String str, String separator)

Source Link

Document

Gets the substring after the first occurrence of a separator.

Usage

From source file:com.opengamma.component.OpenGammaComponentServer.java

/**
 * Extracts the server name.//w ww  .  j av a  2  s.com
 * <p>
 * This examines the first part of the file name and the last directory,
 * merging these with a dash.
 * 
 * @param fileName  the name to extract from, not null
 * @return the server name, not null
 */
protected String extractServerName(String fileName) {
    if (fileName.contains(":")) {
        fileName = StringUtils.substringAfter(fileName, ":");
    }
    fileName = FilenameUtils.removeExtension(fileName);
    String first = FilenameUtils.getName(FilenameUtils.getPathNoEndSeparator(fileName));
    String second = FilenameUtils.getName(fileName);
    if (StringUtils.isEmpty(first) || first.equals(second) || second.startsWith(first + "-")) {
        return second;
    }
    return first + "-" + second;
}

From source file:io.ecarf.core.utils.LogParser.java

/**
 * processor.dictionary.AssembleDictionarySubTask - Dictionary size: 44817045
 * @param line//from  www .j a v a2 s .  c  o  m
 * @return
 */
private int extractDictionarySize(String line) {
    return Integer.parseInt(StringUtils.substringAfter(line, DIC_SIZE));
}

From source file:info.magnolia.cms.filters.ServletDispatchingFilterTest.java

@Test
public void testWrapperRespectsForwards()
        throws RepositoryException, IOException, Content2BeanException, ServletException, Node2BeanException {

    String testContent = "" + "/server/filters/servlets/test.class=" + ServletDispatchingFilter.class.getName()
            + "\n" + "/server/filters/servlets/test.servletClass=" + TestServlet.class.getName() + "\n"
            + "/server/filters/servlets/test.servletName=TestServlet\n"
            + "/server/filters/servlets/test.comment=TestComment\n"
            + "/server/filters/servlets/test.parameters.param1=value1\n"
            + "/server/filters/servlets/test.parameters.param2=value2\n"
            + "/server/filters/servlets/test.mappings.mapping.pattern=/mapping/*";

    MockHierarchyManager hm = MockUtil.createHierarchyManager(testContent);

    Node2BeanProcessorImpl n2b = new Node2BeanProcessorImpl(new TypeMappingImpl(),
            new Node2BeanTransformerImpl());

    ServletDispatchingFilter filter = (ServletDispatchingFilter) n2b
            .toBean(hm.getContent("/server/filters/servlets/test").getJCRNode());

    assertEquals("Wrapper for TestServlet servlet", filter.getName());
    assertEquals("TestComment", filter.getComment());
    assertEquals(2, filter.getParameters().size());
    assertEquals("value1", filter.getParameters().get("param1"));
    assertEquals("value2", filter.getParameters().get("param2"));
    assertEquals(1, filter.getMappings().size());
    filter.init(new CustomFilterConfig("test", null));

    MockHttpServletRequest mock = new MockHttpServletRequest();
    mock.setRequestURI("/magnoliaAuthor/mapping/test.html");
    mock.setContextPath("/magnoliaAuthor");
    mock.setServletPath("");
    mock.setPathInfo("/mapping/test.html");

    MgnlContext.getWebContext().getAggregationState()
            .setCurrentURI(StringUtils.substringAfter(mock.getRequestURI(), mock.getContextPath()));
    filter.doFilter(mock, null, null);/*from w  w  w . jav  a  2 s .c o m*/

    filter.destroy();
}

From source file:info.magnolia.cms.filters.RangeSupportFilter.java

private HttpServletResponse wrapResponse(final HttpServletRequest request, final HttpServletResponse response) {
    return new HttpServletResponseWrapper(response) {

        /** default length is max. We hope that the underlying code will set proper content length as a header before we proceed serving some bytes. */
        private int length = Integer.MAX_VALUE;

        private final Map<String, Object> headers = new HashMap<String, Object>();

        private String eTag;

        private List<RangeInfo> ranges;

        private RangeInfo full;

        private ServletOutputStream stream;

        private PrintWriter writer;

        @Override/*from w  w  w  .  jav  a 2  s  . c  o m*/
        public void addDateHeader(String name, long date) {
            super.addDateHeader(name, date);
            this.headers.put(name, date);
            if ("Last-Modified".equalsIgnoreCase(name)) {
                lastModTime = date;
            }
        }

        @Override
        public void setDateHeader(String name, long date) {
            super.setDateHeader(name, date);
            this.headers.put(name, date);
            if ("Last-Modified".equalsIgnoreCase(name)) {
                lastModTime = date;
            }
        }

        @Override
        public void addHeader(String name, String value) {
            if ("Content-Disposition".equalsIgnoreCase(name) && log.isDebugEnabled()) {
                log.warn("content disposition enforced by underlying filter/servlet");
            }
            super.addHeader(name, value);
            this.headers.put(name, value);
        }

        @Override
        public void setHeader(String name, String value) {
            if ("Content-Disposition".equalsIgnoreCase(name) && log.isDebugEnabled()) {
                log.warn("content disposition enforced by underlying filter/servlet");
            }
            super.setHeader(name, value);
            this.headers.put(name, value);
        }

        @Override
        public void addIntHeader(String name, int value) {
            super.addIntHeader(name, value);
            this.headers.put(name, value);
        }

        @Override
        public void setIntHeader(String name, int value) {
            super.setIntHeader(name, value);
            this.headers.put(name, value);
        }

        @Override
        public void setContentLength(int len) {
            this.length = len;
            // do not propagate length up. We might not be able to change it once it is set. We will set it ourselves once we are ready to serve bytes.
        }

        @Override
        public ServletOutputStream getOutputStream() throws IOException {
            // make sure we set stream only once. Multiple calls to this method are allowed.
            if (this.stream == null) {
                ServletOutputStream stream = super.getOutputStream();
                // wrap the response to filter out everything except desired range
                this.stream = addRangeSupportWrapper(request, response, stream);

                if (!isServeContent || this.stream == null) {
                    // swallow output on head requests
                    this.stream = new ServletOutputStream() {

                        @Override
                        public void write(int b) throws IOException {
                            // do nothing, we do not write any output now
                        }
                    };
                }
            }
            return stream;
        }

        private ServletOutputStream addRangeSupportWrapper(final HttpServletRequest request,
                final HttpServletResponse response, ServletOutputStream stream) throws IOException {
            if (!processContent(request, response)) {
                // we might have to return null stream instead as the previous method already called res.sendError();
                return null;
            }

            if (headers.containsKey("Content-Range")) {
                // doesn't work for tomcat as it accesses underlying stream under our hands!!!
                log.debug("Range request was handled by underlying filter/servlet.");
                return stream;
            }
            if (ranges == null || ranges.isEmpty()) {
                // no op, serve all as usual
                log.debug("Didn't find any range to speak of. Serving all content as usual.");
                if (length != Integer.MAX_VALUE) {
                    // set real length when we know it
                    response.setContentLength(length);
                }
            } else if (ranges.size() == 1) {
                RangeInfo range = ranges.get(0);
                log.debug("Serving range [{}].", range);
                // setting 206 header is essential for some clients. The would abort if response is set to 200
                response.setStatus(SC_PARTIAL_CONTENT);
                stream = new RangedOutputStream(stream, range);
            } else {
                log.error("Requested multiple ranges [{}].", ranges.size());
                // TODO: add support for multiple ranges (sent as multipart request), for now just send error back
                response.setHeader("Content-Range", "bytes */" + length);
                response.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);
                // again we might have to return null stream after calling sendError() as the original stream might no longer be valid
            }
            return stream;
        }

        @Override
        public PrintWriter getWriter() throws IOException {
            if (!wrapWriter) {
                return super.getWriter();
            }
            if (this.writer == null) {
                this.writer = new PrintWriter(new OutputStreamWriter(getOutputStream()));
            }
            return writer;
        }

        private boolean processContent(HttpServletRequest request, HttpServletResponse response)
                throws IOException {
            log.debug("Serving binary on uri {} was last modified at {}",
                    new Object[] { request.getRequestURI(), lastModTime });
            if (!isRequestValid(request, response)) {
                log.debug("Skipping request {} since it doesn't require body",
                        new Object[] { request.getRequestURI() });
                return false;
            }
            if (!processRange(request)) {
                log.debug("Could not process range of request {}", new Object[] { request.getRequestURI() });
                return false;
            }
            return true;
        }

        private boolean processRange(HttpServletRequest request) throws IOException {
            full = new RangeInfo(0, length - 1, length);
            ranges = new ArrayList<RangeInfo>();

            String range = request.getHeader("Range");

            // Valid range header format is "bytes=n-n,n-n,n-n...". If not, then return 416.
            if (!range.matches("^bytes=\\d*-\\d*(,\\d*-\\d*)*$")) {
                response.setHeader("Content-Range", "bytes */" + length);
                response.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);
                return false;
            }

            // If-Range header must match ETag or be greater then LastModified. If not, then return full file.
            String ifRange = request.getHeader("If-Range");
            if (ifRange != null && !ifRange.equals(eTag)) {
                try {
                    long ifRangeTime = request.getDateHeader("If-Range");
                    if (ifRangeTime != -1 && ifRangeTime + 1000 < lastModTime) {
                        ranges.add(full);
                    }
                } catch (IllegalArgumentException ignore) {
                    // happens when if-range contains something else then date
                    ranges.add(full);
                }
            }

            // in case there were no invalid If-Range headers, then look at requested byte ranges.
            if (ranges.isEmpty()) {
                for (String part : range.substring(6).split(",")) {
                    int start = intSubstring(StringUtils.substringBefore(part, "-"));
                    int end = intSubstring(StringUtils.substringAfter(part, "-"));

                    if (start == -1) {
                        start = length - end;
                        end = length - 1;
                    } else if (end == -1 || end > length - 1) {
                        end = length - 1;
                    }

                    // Is range valid?
                    if (start > end) {
                        response.setHeader("Content-Range", "bytes */" + length); // Required in 416.
                        response.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);
                        return false;
                    }

                    // Add range.
                    ranges.add(new RangeInfo(start, end, length));
                }
            }

            response.setHeader("ETag", eTag);
            if (ranges.size() == 1) {
                RangeInfo r = ranges.get(0);
                response.setHeader("Accept-Ranges", "bytes");
                response.setHeader("Content-Range",
                        "bytes " + r.start + "-" + r.end + "/" + r.totalLengthOfServedBinary);
                length = r.lengthOfRange;
            }
            return true;
        }

        private int intSubstring(String value) {
            return value.length() > 0 ? Integer.parseInt(value) : -1;
        }

        @Override
        public void flushBuffer() throws IOException {
            if (writer != null) {
                writer.flush();
            }
            if (stream != null) {
                stream.flush();
            }

            super.flushBuffer();
        }

        private boolean isRequestValid(HttpServletRequest request, HttpServletResponse response)
                throws IOException {
            String fileName = StringUtils.substringAfterLast(request.getRequestURI(), "/");
            eTag = fileName + "_" + length + "_" + lastModTime;

            // If-None-Match header should contain "*" or ETag.
            String ifNoneMatch = request.getHeader("If-None-Match");
            if (ifNoneMatch != null && matches(ifNoneMatch, eTag)) {
                response.setHeader("ETag", eTag); // Required in 304.
                log.debug("Returning {} on header If-None-Match", HttpServletResponse.SC_NOT_MODIFIED);
                response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
                return false;
            }

            // If-Modified-Since header must be greater than LastModified. ignore if If-None-Match header exists
            long ifModifiedSince = request.getDateHeader("If-Modified-Since");
            if (ifNoneMatch == null && ifModifiedSince != -1 && ifModifiedSince + 1000 > lastModTime) {
                response.setHeader("ETag", eTag); // Required in 304.
                // 304 response should contain Date header unless running on timeless server (see 304 response docu)
                response.addDateHeader("Date", lastModTime);
                log.debug("Returning {} on header If-Modified-Since", HttpServletResponse.SC_NOT_MODIFIED);
                response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
                return false;
            }

            // If-Match header should contain "*" or ETag.
            String ifMatch = request.getHeader("If-Match");
            if (ifMatch != null && !matches(ifMatch, eTag)) {
                log.debug("Returning {} on header If-Match", HttpServletResponse.SC_PRECONDITION_FAILED);
                response.sendError(HttpServletResponse.SC_PRECONDITION_FAILED);
                return false;
            }

            // If-Unmodified-Since header must be greater than LastModified.
            long ifUnmodifiedSince = request.getDateHeader("If-Unmodified-Since");
            if (ifUnmodifiedSince != -1 && ifUnmodifiedSince + 1000 <= lastModTime) {
                log.debug("Returning {} on header If-Unmodified-Since",
                        HttpServletResponse.SC_PRECONDITION_FAILED);
                response.sendError(HttpServletResponse.SC_PRECONDITION_FAILED);
                return false;
            }

            log.debug("Passed all precondition checkes for request {}", request.getRequestURI());
            return true;
        }
    };
}

From source file:com.amalto.core.query.user.UserQueryHelper.java

private static Boolean isRealXpath(MetadataRepository repository, String rightValueOrPath) {
    if (rightValueOrPath != null && rightValueOrPath.contains("/")) { //$NON-NLS-1$
        String rightTypeName = StringUtils.substringBefore(rightValueOrPath, "/"); //$NON-NLS-1$
        ComplexTypeMetadata metaData = repository.getComplexType(rightTypeName);
        if (repository.getComplexType(rightTypeName) != null) {
            String rightFieldName = StringUtils.substringAfter(rightValueOrPath, "/"); //$NON-NLS-1$
            if (metaData.getField(rightFieldName) != null) {
                return true;
            }//from www. j ava 2  s .c  o  m
        }
    }
    return false;
}

From source file:com.hangum.tadpole.rdb.core.viewers.object.sub.utils.TadpoleObjectQuery.java

/**
 * @param userDB//from  w  ww . j  a  v a 2 s .  c  om
 * @param strObject
 * @return
 */
public static TableDAO getTable(UserDBDAO userDB, String strObject) throws Exception {
    TableDAO tableDao = null;
    List<TableDAO> showTables = new ArrayList<TableDAO>();

    if (userDB.getDBDefine() == DBDefine.TAJO_DEFAULT) {
        List<TableDAO> tmpShowTables = new TajoConnectionManager().tableList(userDB);

        for (TableDAO dao : tmpShowTables) {
            if (dao.getName().equals(strObject)) {
                showTables.add(dao);
                break;
            }
        }
    } else if (userDB.getDBDefine() == DBDefine.HIVE_DEFAULT | userDB.getDBDefine() == DBDefine.HIVE2_DEFAULT) {
        SqlMapClient sqlClient = TadpoleSQLManager.getInstance(userDB);
        List<TableDAO> tmpShowTables = sqlClient.queryForList("tableList", userDB.getDb()); //$NON-NLS-1$

        for (TableDAO dao : tmpShowTables) {
            if (dao.getName().equals(strObject)) {
                showTables.add(dao);
                break;
            }
        }
    } else if (userDB.getDBDefine() == DBDefine.ALTIBASE_DEFAULT) {
        Map<String, Object> mapParam = new HashMap<String, Object>();

        mapParam.put("user_name", StringUtils.substringBefore(strObject, ".")); //$NON-NLS-1$
        mapParam.put("table_name", StringUtils.substringAfter(strObject, ".")); //$NON-NLS-1$

        SqlMapClient sqlClient = TadpoleSQLManager.getInstance(userDB);
        showTables = sqlClient.queryForList("table", mapParam); //$NON-NLS-1$
    } else {
        Map<String, Object> mapParam = new HashMap<String, Object>();
        mapParam.put("db", userDB.getDb()); //$NON-NLS-1$
        mapParam.put("name", strObject); //$NON-NLS-1$

        SqlMapClient sqlClient = TadpoleSQLManager.getInstance(userDB);
        showTables = sqlClient.queryForList("table", mapParam); //$NON-NLS-1$         
    }

    /** filter   . */
    showTables = DBAccessCtlManager.getInstance().getTableFilter(showTables, userDB);

    if (!showTables.isEmpty()) {
        tableDao = showTables.get(0);
        tableDao.setSysName(SQLUtil.makeIdentifierName(userDB, tableDao.getName()));
        return tableDao;
    } else {
        return null;
    }
}

From source file:hudson.plugins.clearcase.ClearCaseUcmSCM.java

private String shortenStreamName(String longStream) {
    if (StringUtils.startsWith(longStream, STREAM_PREFIX)) {
        return StringUtils.substringAfter(longStream, STREAM_PREFIX);
    } else {/*from w ww  .j  a va2  s  .c o  m*/
        return longStream;
    }
}

From source file:info.magnolia.cms.security.RepositoryBackedSecurityManager.java

protected Map<String, ACL> getACLs(Node node)
        throws RepositoryException, ValueFormatException, PathNotFoundException {
    Map<String, ACL> principalList = new HashMap<String, ACL>();
    NodeIterator it = new FilteringNodeIterator(node.getNodes(),
            new NodeTypePredicate(ItemType.CONTENTNODE.getSystemName(), true));
    while (it.hasNext()) {
        Node aclEntry = it.nextNode();
        if (!aclEntry.getName().startsWith("acl")) {
            continue;
        }//from w w  w . j  av  a2  s .com
        String name = StringUtils.substringAfter(aclEntry.getName(), "acl_");

        List<Permission> permissionList = new ArrayList<Permission>();
        // add acl
        NodeIterator permissionIterator = new FilteringNodeIterator(aclEntry.getNodes(),
                new NodeTypePredicate(ItemType.CONTENTNODE.getSystemName(), true));
        while (permissionIterator.hasNext()) {
            Node map = permissionIterator.nextNode();
            String path = map.getProperty("path").getString();
            UrlPattern p = new SimpleUrlPattern(path);
            Permission permission = new PermissionImpl();
            permission.setPattern(p);
            permission.setPermissions(map.getProperty("permissions").getLong());
            permissionList.add(permission);
        }

        ACL acl;
        // get the existing acl object if created before with some
        // other role
        if (principalList.containsKey(name)) {
            acl = principalList.get(name);
            permissionList.addAll(acl.getList());
        }
        acl = new ACLImpl(name, permissionList);
        principalList.put(name, acl);

    }
    return principalList;
}

From source file:info.magnolia.link.LinkUtilTest.java

@Test
public void testMakeCompleteURL() throws Exception {
    ServerConfiguration serverConfiguration = Components.getComponent(ServerConfiguration.class);
    String base = serverConfiguration.getDefaultBaseUrl();
    serverConfiguration.setDefaultBaseUrl("http://some.site/yay/");
    String url = null;/*ww  w . jav  a 2s.  c o m*/
    try {
        MockSession session = new MockSession("website");
        MockNode c = (MockNode) session.getRootNode();
        url = LinkTransformerManager.getInstance().getCompleteUrl().transform(LinkUtil.createLinkInstance(c));
    } finally {
        // restore
        serverConfiguration.setDefaultBaseUrl(base);
    }
    assertNotNull(url);
    assertEquals(-1, StringUtils.substringAfter(url, "http://").indexOf("//"));
}

From source file:eionet.cr.util.Util.java

/**
 *
 * @param acceptLanguageHeader/*  w w w  .jav  a  2  s.  c o m*/
 * @return
 */
public static List<String> getAcceptedLanguages(String acceptLanguageHeader) {

    final HashMap<String, Double> languageMap = new LinkedHashMap<String, Double>();
    if (!StringUtils.isBlank(acceptLanguageHeader)) {

        String[] languageStrings = StringUtils.split(acceptLanguageHeader, ',');
        for (int i = 0; i < languageStrings.length; i++) {

            String languageString = languageStrings[i].trim();
            String languageCode = StringUtils.substringBefore(languageString, ";").trim();
            if (!StringUtils.isEmpty(languageCode)) {

                String languageCodeUnrefined = StringUtils.split(languageCode, "-_")[0];
                String qualityString = StringUtils.substringAfter(languageString, ";").trim();
                double qualityValue = NumberUtils.toDouble(StringUtils.substringAfter(qualityString, "="),
                        1.0d);

                Double existingQualityValue = languageMap.get(languageCodeUnrefined);
                if (existingQualityValue == null || qualityValue > existingQualityValue) {
                    languageMap.put(languageCodeUnrefined, Double.valueOf(qualityValue));
                }
            }
        }
    }

    ArrayList<String> result = new ArrayList<String>(languageMap.keySet());
    Collections.sort(result, new Comparator() {

        @Override
        public int compare(Object o1, Object o2) {
            return (-1) * languageMap.get(o1).compareTo(languageMap.get(o2));
        }
    });

    if (!result.contains("en")) {
        result.add("en");
    }
    result.add("");
    return result;
}