protected String cleanseValue(String value) {
value = StringUtils.trim(value);
value = StringUtils.removeStart(value, "'");
value = StringUtils.removeStart(value, "\"");
value = StringUtils.removeEnd(value, "\"");
value = StringUtils.removeEnd(value, "'");
value = StringUtils.trim(value);
return value;
}
public static File convertRpmToZip(File file) throws Exception {
LOG.info("File: " + file.getAbsolutePath());
FileInputStream fis = new FileInputStream(file);
ReadableChannelWrapper in = new ReadableChannelWrapper(Channels.newChannel(fis));
InputStream uncompressed = new GZIPInputStream(fis);
in = new ReadableChannelWrapper(Channels.newChannel(uncompressed));
String rpmZipName = file.getName();
rpmZipName = StringUtils.replace(rpmZipName, ".", "-");
rpmZipName = rpmZipName + ".zip";
String rpmZipPath = FilenameUtils.getFullPath(file.getAbsolutePath());
File rpmZipOutput = new File(rpmZipPath + File.separator + rpmZipName);
LOG.info("Converting RPM: " + file.getName() + " to ZIP: " + rpmZipOutput.getName());
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(rpmZipOutput));
String rpmName = file.getName();
rpmName = StringUtils.replace(rpmName, ".", "-");
CpioHeader header;
int total = 0;
do {
header = new CpioHeader();
total = header.read(in, total);
if (header.getFileSize() > 0) {
BoundedInputStream bis = new BoundedInputStream(uncompressed, header.getFileSize());
String relPath = FilenameUtils.separatorsToSystem(header.getName());
relPath = StringUtils.removeStart(relPath, ".");
relPath = StringUtils.removeStart(relPath, "/");
relPath = rpmName + File.separator + relPath;
relPath = StringUtils.replace(relPath, "\\", "/");
ZipEntry zipEntry = new ZipEntry(relPath);
zos.putNextEntry(zipEntry);
IOUtils.copy(bis, zos);
} else {
final int skip = header.getFileSize();
if (uncompressed.skip(skip) != skip) throw new RuntimeException("Skip failed.");
}
total += header.getFileSize();
} while (!header.isLast());
zos.flush();
zos.close();
return rpmZipOutput;
}
@Override
protected void doPerModuleVersioning(StaplerRequest req) {
releaseVersionPerModule = Maps.newHashMap();
nextVersionPerModule = Maps.newHashMap();
Enumeration params = req.getParameterNames();
while (params.hasMoreElements()) {
String key = (String) params.nextElement();
if (key.startsWith("release.")) {
releaseVersionPerModule.put(
StringUtils.removeStart(key, "release."), req.getParameter(key));
} else if (key.startsWith("next.")) {
nextVersionPerModule.put(StringUtils.removeStart(key, "next."), req.getParameter(key));
}
}
}
private static String[] getOutputArgs(String[] args) {
ArrayList<String> l = new ArrayList<String>();
for (String arg : args) {
if (arg.startsWith("-a")) l.add(StringUtils.removeStart(arg, "-a"));
}
return l.toArray(new String[l.size()]);
}
/**
* convert email address mapping<br>
* <code>user-</code> will be replace by the email address of the user as stored in the user
* repository <code>group-</code> will
*/
public String convertEmailList(String mailTo) {
StringBuffer ret = new StringBuffer();
String[] list = mailTo.split(";");
if (list == null) {
return "";
}
for (int i = 0; i < list.length; i++) { // for each item
String userName = list[i];
if (i != 0) {
ret.append("\n");
}
if (userName.startsWith(MailConstants.PREFIX_USER)) {
userName = StringUtils.removeStart(userName, MailConstants.PREFIX_USER);
if (log.isDebugEnabled()) {
log.debug("username =" + userName);
}
ret.append(getUserMail(userName));
} else if (userName.startsWith(MailConstants.PREFIX_GROUP)) {
} else if (userName.startsWith(MailConstants.PREFIX_ROLE)) {
} else {
// none of the above, just add the mail to the list
ret.append(userName);
}
}
return ret.toString();
}
protected Document filterAndAssertOutput(
String input, Map<String, String> cleaningParameters, String expectedOuput) {
Document document = filter(input, cleaningParameters);
String output = XMLUtils.serialize(document, false);
output = StringUtils.removeStart(output, "<root>");
output = StringUtils.removeEnd(output, "</root>");
Assert.assertEquals(expectedOuput, output);
return document;
}
/**
* Executes this script node if necessary and/or possible.
*
* @param executeIfDeferred if <tt>false</tt>, and we are emulating IE, and the <tt>defer</tt>
* attribute is defined, the script is not executed
*/
void executeScriptIfNeeded() {
if (!isExecutionNeeded()) {
return;
}
final HtmlPage page = (HtmlPage) getPage();
final BrowserVersion browser = page.getWebClient().getBrowserVersion();
final String src = getSrcAttribute();
if (src.equals(SLASH_SLASH_COLON)) {
return;
}
if (src != ATTRIBUTE_NOT_DEFINED) {
if (src.startsWith(JavaScriptURLConnection.JAVASCRIPT_PREFIX)) {
// <script src="javascript:'[code]'"></script>
if (browser.hasFeature(BrowserVersionFeatures.HTMLSCRIPT_SRC_JAVASCRIPT)) {
String code =
StringUtils.removeStart(src, JavaScriptURLConnection.JAVASCRIPT_PREFIX).trim();
final int len = code.length();
if (len > 2) {
if ((code.charAt(0) == '\'' && code.charAt(len - 1) == '\'')
|| (code.charAt(0) == '"' && code.charAt(len - 1) == '"')) {
code = code.substring(1, len - 1);
if (LOG.isDebugEnabled()) {
LOG.debug("Executing JavaScript: " + code);
}
page.executeJavaScriptIfPossible(code, code, getStartLineNumber());
}
}
}
} else {
// <script src="[url]"></script>
if (LOG.isDebugEnabled()) {
LOG.debug("Loading external JavaScript: " + src);
}
try {
final JavaScriptLoadResult result =
page.loadExternalJavaScriptFile(src, getCharsetAttribute());
if (result == JavaScriptLoadResult.SUCCESS) {
executeEventIfBrowserHasFeature(
Event.TYPE_LOAD, BrowserVersionFeatures.EVENT_ONLOAD_EXTERNAL_JAVASCRIPT);
} else if (result == JavaScriptLoadResult.DOWNLOAD_ERROR) {
executeEventIfBrowserHasFeature(
Event.TYPE_ERROR, BrowserVersionFeatures.EVENT_ONERROR_EXTERNAL_JAVASCRIPT);
}
} catch (final FailingHttpStatusCodeException e) {
executeEventIfBrowserHasFeature(
Event.TYPE_ERROR, BrowserVersionFeatures.EVENT_ONERROR_EXTERNAL_JAVASCRIPT);
throw e;
}
}
} else if (getFirstChild() != null) {
// <script>[code]</script>
executeInlineScriptIfNeeded();
}
}
public Collection getOrCreateCollection(String path) throws XMLDBException {
path = StringUtils.removeStart(path, "/");
path = StringUtils.removeEnd(path, "/");
path = path.replaceAll("[/]+", "/");
String pathWithURI = uri + path;
Collection col = DatabaseManager.getCollection(pathWithURI, userName, password);
if (col != null) {
return col;
} else {
synchronized (syncLock) {
col = DatabaseManager.getCollection(pathWithURI, userName, password);
if (col != null) {
return col;
}
String[] paths = path.split("/");
String[] parentPath = (String[]) ArrayUtils.remove(paths, paths.length - 1);
this.getOrCreateCollection(StringUtils.join(parentPath, '/'));
CollectionManagementService mgt = this.getCollectionManagementService();
col = mgt.createCollection(StringUtils.join(paths, '/'));
// If we are creating a new root collection, we need to set up the indexing configuration
// for this collection,
// which is done by placing a collection.xconf file into the config path structure.
if (paths.length == 1 && getCollectionRoot().endsWith(paths[0])) {
log.info("Configuring Indexes for Collection " + paths[0]);
// Add the index configuration file for our root config
try {
String confFilePath = "/collection.xconf";
String confFileXml =
IOUtils.toString(this.getClass().getResourceAsStream(confFilePath), "UTF-8");
Collection configCol = getOrCreateCollection("/system/config/db/" + paths[0]);
org.xmldb.api.base.Resource r =
configCol.createResource("collection.xconf", "XMLResource");
r.setContent(confFileXml);
configCol.storeResource(r);
log.info(
"Wrote index configuration " + r.getParentCollection().getName() + "/" + r.getId());
} catch (Exception e) {
log.error(
"Failure configuring indexes for collection "
+ paths[0]
+ " - indexes will not be available!",
e);
}
}
return col;
}
}
}
/**
* Only if the path template starts with the datadir, return a path relative to it, otherwise
* return an absolute path.
*/
protected String getFilePathRelativeToDataDirIfPossible() {
String template = getFilePathTemplate();
if (StringUtils.startsWith(template, "$datadir$")) {
template = StringUtils.replace(template, "$datadir$", "");
template = StringUtils.removeStart(template, "/");
} else {
template = substituteDatadir(template);
}
return substituteScan(template);
}
private P2Repo resolveLocalP2RepoFromUrl(String url) {
String rpp = StringUtils.removeStart(url, "local://");
// rpp = rpp.substring(0, rpp.indexOf('/'));
RepoPath repoPath = RepoPathFactory.create(rpp);
LocalRepoDescriptor localRepoDescriptor =
centralConfig.getMutableDescriptor().getLocalRepositoriesMap().get(repoPath.getRepoKey());
if (localRepoDescriptor != null) {
return new P2Repo(null, repoPath.getRepoKey(), url);
}
return null;
}
private static String getOutputDir(String[] args) {
String outputDir = null;
for (String arg : args) {
if (arg.startsWith("-o")) {
outputDir = StringUtils.removeStart(arg, "-o");
break;
}
}
if (outputDir == null) outputDir = new File("").getAbsolutePath();
return outputDir;
}
@Override
public String getBranchName(String branch) {
String value = branch;
for (String prefix : configuration.getBranchNamePrefixes()) {
value = StringUtils.removeStart(value, prefix);
}
// Normalisation
value = Configuration.normalise(value);
// Evaluation
return evaluate(configuration.getBranchNameExpression(), "branch", value);
}
/**
* Gets the relative path of a file contained in the project. <br>
* For example, if the visual studio project is C:/MySolution/MyProject/MyProject.csProj and the
* file is C:/MySolution/MyProject/Dummy/Foo.cs, then the result is Dummy/Foo.cs
*
* @param file the file whose relative path is to be computed
* @return the relative path, or <code>null</code> if the file is not in the project
* subdirectories
*/
public String getRelativePath(File file) {
File canonicalDirectory;
try {
canonicalDirectory = directory.getCanonicalFile();
File canonicalFile = file.getCanonicalFile();
String filePath = canonicalFile.getPath();
String directoryPath = canonicalDirectory.getPath();
if (!filePath.startsWith(directoryPath)) {
// The file is not in the directory
return null;
}
return StringUtils.removeStart(StringUtils.removeStart(filePath, directoryPath), "\\");
} catch (IOException e) {
if (LOG.isDebugEnabled()) {
LOG.debug("io exception with file " + file, e);
}
return null;
}
}
public static String sanitize(String mavenArtifactId) {
String key = mavenArtifactId;
if (StringUtils.startsWith(mavenArtifactId, SONAR_PREFIX)
&& StringUtils.endsWith(mavenArtifactId, PLUGIN_SUFFIX)) {
key =
StringUtils.removeEnd(
StringUtils.removeStart(mavenArtifactId, SONAR_PREFIX), PLUGIN_SUFFIX);
} else if (StringUtils.endsWith(mavenArtifactId, SONAR_PLUGIN_SUFFIX)) {
key = StringUtils.removeEnd(mavenArtifactId, SONAR_PLUGIN_SUFFIX);
}
return keepLettersAndDigits(key);
}
private static Output createOutput(String[] args) {
String outputClass = null;
for (String arg : args) {
if (arg.startsWith("-c")) {
outputClass = StringUtils.removeStart(arg, "-c");
break;
}
}
if (outputClass == null) outputClass = XmlOutput.class.getName();
return (Output) ClassHelper.newInstance(outputClass);
}
@Override
public RootContainer<String, IRepositoryViewObject> getTdqRepositoryViewObjects(
Project project, ERepositoryObjectType type, String folderName, boolean[] options)
throws PersistenceException {
String relativeFolder = folderName;
if (type != null && type.hasFolder()) {
// Compatible to the existing behavior which keep the full path relative to the project in DQ.
String baseFolder = ERepositoryObjectType.getFolderName(type);
relativeFolder = StringUtils.removeStart(relativeFolder, baseFolder);
}
return getObjectFromFolder(
project, type, relativeFolder, OPTION_ONLY_LAST_VERSION | OPTION_DYNAMIC_OBJECTS);
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
final HttpServletRequest servletRequest = (HttpServletRequest) request;
String requestURI = servletRequest.getRequestURI();
requestURI =
StringUtils.removeStart(
requestURI, servletRequest.getContextPath() + servletRequest.getServletPath());
String baseURL = StringUtils.removeEnd(servletRequest.getRequestURL().toString(), requestURI);
Map<String, List<String>> headersMap = new HashMap<>();
Enumeration<String> headerNames = servletRequest.getHeaderNames();
if (headerNames != null) {
while (headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement();
List<String> valuesList = Collections.list(servletRequest.getHeaders(headerName));
headersMap.put(headerName, valuesList);
}
}
RequestContext ctx;
Principal userPrincipal = servletRequest.getUserPrincipal();
if (userPrincipal != null) {
ctx =
new RequestContext(
baseURL,
servletRequest.getRequestURI(),
servletRequest.getHeader(RequestContext.HATEOAS_OPTIONS_HEADER),
userPrincipal,
headersMap);
} else {
ctx =
new RequestContext(
baseURL,
servletRequest.getRequestURI(),
servletRequest.getHeader(RequestContext.HATEOAS_OPTIONS_HEADER),
headersMap);
}
RequestContext.setRequestContext(ctx);
try {
chain.doFilter(request, response);
} finally {
RequestContext.clearRequestContext();
}
}
protected void process(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// L.trace("begin process");
String url =
StringUtils.removeStart(
StringUtils2.joinIgnoreNull(req.getServletPath(), req.getPathInfo()), "/");
if (processDocument(url, req, resp)) return;
Invoker invoker = invokers.get(url);
if (invoker != null) {
invoker.invoke(req, resp);
} else {
resp.setStatus(404); // Not Found
}
// L.trace("end process");
}
@Override
protected String baseIntercept(
ActionInvocation invoke, HttpServletRequest req, HttpServletResponse resp) throws Exception {
// TODO Auto-generated method stub
/**
* This interceptor is used for urls invoked using SEO type urls The system is configured to
* support /category/category-name /product/product-name /pagelink/page-name
*/
// get the product from the path
String path = StringUtils.removeStart(req.getRequestURI(), req.getContextPath());
/**
* should have left /category/<PRODUCT-URL>?request parameters or should have left
* /pagelink/<PAGE-URL>?request parameters or should have left /product/<PRODUCT-URL>?request
* parameters keep after second / and before ?
*/
// remove /product or /category or /page
String pathnocontext = path.substring(1); // remove /
// should now have product/<PRODUCT-ID>?request parameters or
// category/<CATEGORY-ID>?request parameters or pagelink/<PAGE-ID>
String[] parameters = pathnocontext.split("/");
// should now have
// parameters[0] = product or category or pagelink
// parameters[1] = <PRODUCT-ID>?parameters
if (parameters == null || parameters.length == 1) {
throw new Exception("Invalid parameters in request " + path);
}
String id = parameters[1];
if (id.contains(".action")) {
id = id.substring(0, id.indexOf(".action"));
}
SalesManagerBaseAction action = ((SalesManagerBaseAction) invoke.getAction());
action.setRequestedEntityId(id);
return null;
}
public User getUserDataFromFacebook(String faceCode, HttpServletRequest request) {
User user = new User();
String token = null;
if (faceCode != null && !"".equals(faceCode)) {
String redirectUrl =
request.getScheme()
+ "://"
+ request.getServerName()
+ ":"
+ request.getServerPort()
+ request.getContextPath()
+ "/socialSignUp";
String newUrl =
"https://graph.facebook.com/oauth/access_token?client_id="
+ APP_ID
+ "&redirect_uri="
+ redirectUrl
+ "&client_secret="
+ APP_SECRET
+ "&code="
+ faceCode;
HttpClient httpclient = new DefaultHttpClient();
try {
String responseBody = "";
HttpGet httpget = new HttpGet(newUrl);
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
responseBody = EntityUtils.toString(entity);
token =
StringUtils.removeEnd(
StringUtils.removeStart(responseBody, "access_token="), "&expires=5180795");
} catch (ClientProtocolException e) {
log.error(e);
} catch (IOException e) {
log.error(e);
} finally {
httpclient.getConnectionManager().shutdown();
}
}
user = getUserFromJsonResponse(token);
return user;
}
public void doPost(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws ServletException, IOException {
if (!authenticate(request, response)) {
return;
}
final String msgId = StringUtils.removeStart(request.getRequestPathInfo().getSuffix(), "/");
if (StringUtils.isBlank(msgId)) {
throw new ServletException("No suffix found");
}
if (!sentMessages.contains(msgId)) {
throw new ServletException("No one is waiting for confirmation for " + msgId);
} else {
receivedConfirmations.add(msgId);
synchronized (receivedConfirmations) {
receivedConfirmations.notifyAll();
}
response.getWriter().append("Message " + msgId + " confirmed");
LOG.debug("Message " + msgId + " confirmed");
}
}
/**
* Return string array containing the paths in the view that should be used when polling for
* changes.
*
* @param variableResolver TODO
* @param build TODO
* @param launcher TODO
* @return string array that will be used by the lshistory command and for constructing the config
* spec, etc.
* @throws InterruptedException
* @throws IOException
*/
public String[] getViewPaths(
VariableResolver<String> variableResolver, AbstractBuild build, Launcher launcher)
throws IOException, InterruptedException {
String loadRules = getLoadRules();
if (StringUtils.isBlank(loadRules)) {
return null;
}
String[] rules = loadRules.split("[\\r\\n]+");
for (int i = 0; i < rules.length; i++) {
String rule = rules[i];
// Remove "load " from the string, just in case.
rule = StringUtils.removeStart(rule, "load ");
// Remove "\\", "\" or "/" from the load rule. (bug#1706) Only if
// the view is not dynamic
// the user normally enters a load rule beginning with those chars
rule = StringUtils.stripStart(rule, "\\/");
rules[i] = rule;
}
return rules;
}
protected void process(HttpServletRequest hreq, HttpServletResponse hresp)
throws ServletException, IOException {
Request req = createRequest(hreq, hresp);
if (L.isDebugEnabled()) L.debug(null, req.toString());
Response resp = createResponse(hreq, hresp);
try {
fireBeforeAll(req, resp);
if (routeSummary
&& "$"
.equals(StringUtils.removeStart(StringUtils.trimToEmpty(hreq.getPathInfo()), "/"))) {
resp.body(RawText.of(makeRouteSummary()));
resp.type("text/plain");
} else {
invokeAllMatched(before, req, resp);
boolean matched = invokeFirstMatched(routes, req, resp);
invokeAllMatched(after, req, resp);
if (!matched) TopazHelper.halt(404, "Route error");
if (L.isDebugEnabled()) L.debug(null, "ok");
}
fireSuccess(req, resp);
} catch (Throwable t) {
fireExceptionCaught(req, resp, t);
Throwable c =
(t instanceof InvocationTargetException)
? ((InvocationTargetException) t).getTargetException()
: t;
if (!(c instanceof QuietHaltException)) resp.error(c);
L.warn(null, c, "error");
} finally {
fireBeforeOutput(req, resp);
resp.doOutput(Response.OutputOptions.fromRequest(req));
fireAfterOutput(req, resp);
req.deleteUploadedFiles();
fireAfterAll(req, resp);
if (L.isDebugEnabled()) L.debug(null, "complete");
}
}
/**
* Finds directories and files within a given directory and its subdirectories.
*
* @param classLoader
* @param rootPath the root directory, for example org/sonar/sqale, or a file in this root
* directory, for example org/sonar/sqale/index.txt
* @param
* @return a list of relative paths, for example {"org/sonar/sqale", "org/sonar/sqale/foo",
* "org/sonar/sqale/foo/bar.txt}. Never null.
*/
public static Collection<String> listResources(
ClassLoader classLoader, String rootPath, Predicate<String> predicate) {
String jarPath = null;
JarFile jar = null;
try {
Collection<String> paths = Lists.newArrayList();
rootPath = StringUtils.removeStart(rootPath, "/");
URL root = classLoader.getResource(rootPath);
if (root != null) {
checkJarFile(root);
// Path of the root directory
// Examples :
// org/sonar/sqale/index.txt -> rootDirectory is org/sonar/sqale
// org/sonar/sqale/ -> rootDirectory is org/sonar/sqale
// org/sonar/sqale -> rootDirectory is org/sonar/sqale
String rootDirectory = rootPath;
if (StringUtils.substringAfterLast(rootPath, "/").indexOf('.') >= 0) {
rootDirectory = StringUtils.substringBeforeLast(rootPath, "/");
}
jarPath =
root.getPath().substring(5, root.getPath().indexOf("!")); // strip out only the JAR file
jar = new JarFile(URLDecoder.decode(jarPath, CharEncoding.UTF_8));
Enumeration<JarEntry> entries = jar.entries();
while (entries.hasMoreElements()) {
String name = entries.nextElement().getName();
if (name.startsWith(rootDirectory) && predicate.apply(name)) {
paths.add(name);
}
}
}
return paths;
} catch (Exception e) {
throw Throwables.propagate(e);
} finally {
closeJar(jar, jarPath);
}
}
@CheckForNull
@Override
protected SCMRevision retrieve(@NonNull SCMHead head, @NonNull TaskListener listener)
throws IOException, InterruptedException {
String cacheEntry = getCacheEntry();
Lock cacheLock = getCacheLock(cacheEntry);
cacheLock.lock();
try {
File cacheDir = getCacheDir(cacheEntry);
Git git =
Git.with(listener, new EnvVars(System.getenv()))
.in(cacheDir)
.using(GitTool.getDefaultInstallation().getGitExe());
GitClient client = git.getClient();
client.addDefaultCredentials(getCredentials());
if (!client.hasGitRepo()) {
listener.getLogger().println("Creating git repository in " + cacheDir);
client.init();
}
String remoteName = getRemoteName();
listener.getLogger().println("Setting " + remoteName + " to " + getRemote());
client.setRemoteUrl(remoteName, getRemote());
listener.getLogger().println("Fetching " + remoteName + "...");
List<RefSpec> refSpecs = getRefSpecs();
client.fetch(remoteName, refSpecs.toArray(new RefSpec[refSpecs.size()]));
// we don't prune remotes here, as we just want one head's revision
for (Branch b : client.getRemoteBranches()) {
String branchName = StringUtils.removeStart(b.getName(), remoteName + "/");
if (branchName.equals(head.getName())) {
return new SCMRevisionImpl(head, b.getSHA1String());
}
}
return null;
} finally {
cacheLock.unlock();
}
}
public List<V> getRelaxedValue(final String sourceKey, final String[] keywordPrecedence) {
// TODO - lookup in the relaxed map, based on the keyword precedence
String baseLine = null;
for (final String altKeyword : keywordPrecedence) {
baseLine = StringUtils.removeStart(sourceKey, altKeyword);
if (!baseLine.equals(sourceKey)) {
break;
}
}
List<V> vals = null;
for (final String altKeyword : keywordPrecedence) {
vals = get(altKeyword + baseLine);
if (!vals.isEmpty()) {
break;
}
}
return vals;
}
@Override
public Pair<Pair<String, Long>, List<WeiboContent>> read() throws Exception {
Long txFollowerId = follower.getSeqId();
OAuth oauth = TencentOAuthCache.getOAuth(txFollowerId, true);
if (oauth == null) {
log.info("no tx oauth,please check it " + txFollowerId);
throw new Exception("no tencent cache");
}
String lastId = follower.getLastId();
Long lastTimeStamp = follower.getLastTimeStamp();
String response =
statusesApi.broadcast_timeline(
oauth,
WeiBoConst.ResultType.ResultType_Json,
"2",
lastTimeStamp != null ? lastTimeStamp.toString() : "0",
"100",
lastId != null ? lastId.toString() : "0",
"0",
"0",
"1");
log.info("TencentWeiboServiceImpl.read() " + response);
Object jsonObject = new JSONObject(response).getString("data");
List<WeiboContent> weiboContents = null;
if (jsonObject != null && !"null".equals(jsonObject)) {
JSONArray txWeiboArray = new JSONObject(response).getJSONObject("data").getJSONArray("info");
int size = txWeiboArray.length();
if (size > 0) {
weiboContents = new ArrayList<WeiboContent>(size);
for (int i = 0; i < size; i++) {
JSONObject json = (JSONObject) txWeiboArray.get(i);
String weiboId = json.getString("id");
String image = json.getString("image");
if (!StringUtils.isBlank(image)) {
if ("null".equalsIgnoreCase(image)) {
image = null;
} else {
image =
StringUtils.removeEnd(StringUtils.removeStart(image, "[\""), "\"]")
+ "/2000"; // big image.
}
}
if (!syncRecordService.isSynchronized(txFollowerId, weiboId)) {
weiboContents.add(
new WeiboContent(
weiboId, json.getString("origtext"), image, json.getLong("timestamp")));
} else {
log.info("skip weibo " + json);
}
}
// // asc sort weibo content by id.
// Collections.sort(weiboContents);
// lastId = max = last list
if (weiboContents.size() > 0) {
// lastId = last list
WeiboContent lastWeiboContent = weiboContents.get(weiboContents.size() - 1);
lastId = lastWeiboContent.getId() + "";
lastTimeStamp = lastWeiboContent.getTimeStamp();
}
}
log.info("TencentWeiboServiceImpl.read()" + weiboContents);
}
return new Pair<Pair<String, Long>, List<WeiboContent>>(
new Pair<String, Long>(lastId, lastTimeStamp), weiboContents);
}
private static String removeQuotes(Matcher<? extends String> matcher) {
return StringUtils.removeEnd(StringUtils.removeStart(matcher.toString(), "\""), "\"");
}
private static String getCovertArt(String strHref, String kind) throws IOException {
String strAlbum = StringUtils.removeStart(strHref, String.format("spotify:%s:", kind));
Document document = Jsoup.connect(String.format("%s/%s/%s", BASE_URL, kind, strAlbum)).get();
Element imgElement = document.getElementById(COVER_CSS_ID);
return imgElement.attr(CORVER_CSS_ATTR);
}
@Override
public void init(ActionServlet servlet, ModuleConfig config) throws ServletException {
if (!initialized) {
loadActionsFromFile(actionClasses);
PartialTileDefinition.init();
initialized = true;
}
final String modulePrefix = StringUtils.removeStart(config.getPrefix(), "/");
for (Class<?> actionClass : actionClasses) {
Mapping mapping = actionClass.getAnnotation(Mapping.class);
if (mapping == null || !modulePrefix.equals(mapping.module())) {
continue;
}
final ActionMapping actionMapping = createCustomActionMapping(mapping);
if (actionMapping == null) {
continue;
}
actionMapping.setPath(mapping.path());
actionMapping.setType(actionClass.getName());
actionMapping.setScope(mapping.scope());
actionMapping.setParameter(mapping.parameter());
actionMapping.setValidate(mapping.validate());
if (mapping.formBeanClass() != ActionForm.class) {
final String formName = mapping.formBeanClass().getName();
createFormBeanConfigIfNecessary(config, mapping, formName);
actionMapping.setName(formName);
} else if (!mapping.formBean().isEmpty()) {
actionMapping.setName(mapping.formBean());
}
if (mapping.input().isEmpty()) {
actionMapping.setInput(findInputMethod(actionClass, mapping));
} else {
registerInput(actionMapping, mapping.input());
}
String defaultResourcesName = getDefaultResourcesName(config);
Forwards forwards = actionClass.getAnnotation(Forwards.class);
if (forwards != null) {
for (final Forward forward : forwards.value()) {
registerForward(actionMapping, forward, forwards, mapping, defaultResourcesName);
}
}
registerSuperclassForwards(
actionMapping, actionClass.getSuperclass(), mapping, defaultResourcesName);
Exceptions exceptions = actionClass.getAnnotation(Exceptions.class);
if (exceptions != null) {
registerExceptionHandling(actionMapping, exceptions);
}
initializeActionMappingProperties(actionMapping, mapping.customMappingProperties());
config.addActionConfig(actionMapping);
}
}