public static double call(
PageContext pc, Query query, String string, Object datatype, Object array)
throws PageException {
if (datatype == null) return call(pc, query, string, array);
query.addColumn(
KeyImpl.init(string),
Caster.toArray(array),
SQLCaster.toSQLType(Caster.toString(datatype)));
return query.size();
}
@Override
public Object getValue(Query qr, int row, Object defaultValue) {
if (col == null) {
col = qr.getColumn(getColumn(), null);
if (col == null) return defaultValue;
}
return col.get(row, defaultValue);
}
private static boolean invoke(
PageContext pc, Query qry, UDF udf, ExecutorService es, List<Future<Data<Object>>> futures)
throws CasterException, PageException {
final int pid = pc.getId();
ForEachQueryIterator it = new ForEachQueryIterator(qry, pid);
boolean async = es != null;
double r;
Object res, row;
try {
while (it.hasNext()) {
row = it.next();
r = Caster.toDoubleValue(qry.getCurrentrow(pid));
res = _inv(pc, udf, new Object[] {row, r, qry}, r, row, es, futures);
if (!async && !Caster.toBooleanValue(res)) {
return false;
}
}
} finally {
it.reset();
}
return true;
}
public static Query getMemoryUsageAsQuery(int type) throws DatabaseException {
java.util.List<MemoryPoolMXBean> manager = ManagementFactory.getMemoryPoolMXBeans();
Iterator<MemoryPoolMXBean> it = manager.iterator();
Query qry =
new QueryImpl(
new Collection.Key[] {
KeyConstants._name,
KeyConstants._type,
KeyConstants._used,
KeyConstants._max,
KeyConstants._init
},
0,
"memory");
int row = 0;
MemoryPoolMXBean bean;
MemoryUsage usage;
MemoryType _type;
while (it.hasNext()) {
bean = it.next();
usage = bean.getUsage();
_type = bean.getType();
if (type == MEMORY_TYPE_HEAP && _type != MemoryType.HEAP) continue;
if (type == MEMORY_TYPE_NON_HEAP && _type != MemoryType.NON_HEAP) continue;
row++;
qry.addRow();
qry.setAtEL(KeyConstants._name, row, bean.getName());
qry.setAtEL(KeyConstants._type, row, _type.name());
qry.setAtEL(KeyConstants._max, row, Caster.toDouble(usage.getMax()));
qry.setAtEL(KeyConstants._used, row, Caster.toDouble(usage.getUsed()));
qry.setAtEL(KeyConstants._init, row, Caster.toDouble(usage.getInit()));
}
return qry;
}
// MUST hanle null correctly
@Override
public Object getValue(Query qr, int row) throws PageException {
if (col == null) col = qr.getColumn(getColumn());
return QueryUtil.getValue(col, row);
}
@Override
public final Query getCollectionsAsQuery() {
final String v = "VARCHAR";
Query query = null;
String[] cols =
new String[] {
"external",
"language",
"mapped",
"name",
"online",
"path",
"registered",
"lastmodified",
"categories",
"charset",
"created",
"size",
"doccount"
};
String[] types =
new String[] {
"BOOLEAN", v, "BOOLEAN", v, "BOOLEAN", v, v, "DATE", "BOOLEAN", v, "OBJECT", "DOUBLE",
"DOUBLE"
};
try {
query = engine.getCreationUtil().createQuery(cols, types, collections.size(), "query");
} catch (PageException e) {
query = engine.getCreationUtil().createQuery(cols, collections.size(), "query");
}
// Collection.Key[] keys = collections.keys();
Iterator<Object> it = collections.valueIterator();
int i = -1;
while (it.hasNext()) {
i++;
try {
SearchCollection coll = (SearchCollection) it.next();
query.setAt("external", i + 1, Boolean.FALSE);
query.setAt("charset", i + 1, "UTF-8");
query.setAt("created", i + 1, coll.created());
query.setAt("categories", i + 1, Boolean.TRUE);
query.setAt("language", i + 1, coll.getLanguage());
query.setAt("mapped", i + 1, Boolean.FALSE);
query.setAt("name", i + 1, coll.getName());
query.setAt("online", i + 1, Boolean.TRUE);
query.setAt("path", i + 1, coll.getPath().getAbsolutePath());
query.setAt("registered", i + 1, "CF");
query.setAt("lastmodified", i + 1, coll.getLastUpdate());
query.setAt("size", i + 1, new Double(coll.getSize()));
query.setAt("doccount", i + 1, new Double(coll.getDocumentCount()));
} catch (PageException pe) {
}
}
return query;
}
public static lucee.runtime.type.Query toQuery(
FTPFile[] files, String prefix, String directory, String hostName) throws PageException {
String[] cols =
new String[] {
"name",
"isdirectory",
"lastmodified",
"length",
"mode",
"path",
"url",
"type",
"raw",
"attributes"
};
String[] types =
new String[] {
"VARCHAR", "BOOLEAN", "DATE", "DOUBLE", "VARCHAR", "VARCHAR", "VARCHAR", "VARCHAR",
"VARCHAR", "VARCHAR"
};
lucee.runtime.type.Query query = new QueryImpl(cols, types, 0, "query");
// translate directory path for display
if (directory.length() == 0) directory = "/";
else if (directory.startsWith("./")) directory = directory.substring(1);
else if (directory.charAt(0) != '/') directory = '/' + directory;
if (directory.charAt(directory.length() - 1) != '/') directory = directory + '/';
int row;
for (int i = 0; i < files.length; i++) {
FTPFile file = files[i];
if (file.getName().equals(".") || file.getName().equals("..")) continue;
row = query.addRow();
query.setAt("attributes", row, "");
query.setAt("isdirectory", row, Caster.toBoolean(file.isDirectory()));
query.setAt("lastmodified", row, new DateTimeImpl(file.getTimestamp()));
query.setAt("length", row, Caster.toDouble(file.getSize()));
query.setAt("mode", row, FTPConstant.getPermissionASInteger(file));
query.setAt("type", row, FTPConstant.getTypeAsString(file.getType()));
// query.setAt("permission",row,FTPConstant.getPermissionASInteger(file));
query.setAt("raw", row, file.getRawListing());
query.setAt("name", row, file.getName());
query.setAt("path", row, directory + file.getName());
query.setAt("url", row, prefix + "://" + hostName + "" + directory + file.getName());
}
return query;
}
@Override
public int doStartTag() throws PageException {
// SerialNumber sn = pageContext.getConfig().getSerialNumber();
// if(sn.getVersion()==SerialNumber.VERSION_COMMUNITY)
// throw new SecurityException("no access to this functionality with the
// "+sn.getStringVersion()+" version of Lucee");
final String v = "VARCHAR", d = "DOUBLE";
String[] cols =
new String[] {
"title",
"url",
"summary",
"score",
"recordssearched",
"key",
"custom1",
"custom2",
"custom3",
"custom4",
"categoryTree",
"category",
"context",
"size",
"rank",
"author",
"type",
"collection"
};
// TODO support context
String[] types = new String[] {v, v, v, d, d, v, v, v, v, v, v, v, v, d, d, v, v, v};
SearchData data =
pageContext.getConfig().getSearchEngine(pageContext).createSearchData(suggestions);
SuggestionItem item =
null; // this is already here to make sure the classloader load this sinstance
lucee.runtime.type.Query qry = new QueryImpl(cols, types, 0, "query");
SearchCollection collection;
long time = System.currentTimeMillis();
AddionalAttrs.setAddionalAttrs(
contextBytes, contextPassages, contextHighlightBegin, contextHighlightEnd);
try {
for (int i = 0; i < collections.length; i++) {
collection = collections[i];
startrow =
collection.search(
data,
qry,
criteria,
collection.getLanguage(),
type,
startrow,
maxrows,
categoryTree,
category);
if (maxrows >= 0 && qry.getRecordcount() >= maxrows) break;
}
pageContext.setVariable(name, qry);
} catch (SearchException se) {
throw Caster.toPageException(se);
} finally {
AddionalAttrs.removeAddionalAttrs();
}
time = System.currentTimeMillis() - time;
Double recSearched = new Double(data.getRecordsSearched());
int len = qry.getRecordcount();
for (int i = 1; i <= len; i++) {
qry.setAt("recordssearched", i, recSearched);
}
// status
if (status != null) {
Struct sct = new StructImpl();
pageContext.setVariable(status, sct);
sct.set(FOUND, new Double(qry.getRecordcount()));
sct.set(SEARCHED, recSearched);
sct.set(KeyConstants._time, new Double(time));
// TODO impl this values
Map s = data.getSuggestion();
if (s.size() > 0) {
String key;
Iterator it = s.keySet().iterator();
Struct keywords = new StructImpl();
Struct keywordScore = new StructImpl();
sct.set(KEYWORDS, keywords);
sct.set(KEYWORD_SCORE, keywordScore);
Object obj;
while (it.hasNext()) {
key = (String) it.next();
// the problem is a conflict between the SuggestionItem version from core and extension
obj = s.get(key);
if (obj instanceof SuggestionItem) {
item = (SuggestionItem) obj;
keywords.set(key, item.getKeywords());
keywordScore.set(key, item.getKeywordScore());
} else {
Class clazz = obj.getClass();
try {
keywords.set(
key, clazz.getMethod("getKeywords", new Class[0]).invoke(obj, new Object[0]));
keywordScore.set(
key, clazz.getMethod("getKeywordScore", new Class[0]).invoke(obj, new Object[0]));
} catch (Exception e) {
}
}
}
String query = data.getSuggestionQuery();
if (query != null) {
String html = StringUtil.replace(query, "<suggestion>", "<b>", false);
html = StringUtil.replace(html, "</suggestion>", "</b>", false);
sct.set("suggestedQueryHTML", html);
String plain = StringUtil.replace(query, "<suggestion>", "", false);
plain = StringUtil.replace(plain, "</suggestion>", "", false);
sct.set("suggestedQuery", plain);
}
}
// if(suggestions!=SUGGESTIONS_NEVER)sct.set("suggestedQuery", "");
// sct.set("keywords", "");
// sct.set("keywordScore", "");
}
return SKIP_BODY;
}
public static double call(PageContext pc, Query query, String string, Object array)
throws PageException {
query.addColumn(KeyImpl.init(string), Caster.toArray(array));
return query.size();
}
/** @throws PageException */
private void doList() throws PageException {
// if(tr ue) throw new PageRuntimeException("qqq");
ScheduleTask[] tasks = scheduler.getAllScheduleTasks();
final String v = "VARCHAR";
String[] cols =
new String[] {
"task",
"path",
"file",
"startdate",
"starttime",
"enddate",
"endtime",
"url",
"port",
"interval",
"timeout",
"username",
"password",
"proxyserver",
"proxyport",
"proxyuser",
"proxypassword",
"resolveurl",
"publish",
"valid",
"paused",
"autoDelete"
};
String[] types =
new String[] {
v, v, v, "DATE", "OTHER", "DATE", "OTHER", v, v, v, v, v, v, v, v, v, v, v, "BOOLEAN", v,
"BOOLEAN", "BOOLEAN"
};
lucee.runtime.type.Query query = new QueryImpl(cols, types, tasks.length, "query");
try {
for (int i = 0; i < tasks.length; i++) {
int row = i + 1;
ScheduleTask task = tasks[i];
query.setAt(KeyConstants._task, row, task.getTask());
if (task.getResource() != null) {
query.setAt(KeyConstants._path, row, task.getResource().getParent());
query.setAt(KeyConstants._file, row, task.getResource().getName());
}
query.setAt("publish", row, Caster.toBoolean(task.isPublish()));
query.setAt("startdate", row, task.getStartDate());
query.setAt("starttime", row, task.getStartTime());
query.setAt("enddate", row, task.getEndDate());
query.setAt("endtime", row, task.getEndTime());
query.setAt(KeyConstants._url, row, printUrl(task.getUrl()));
query.setAt(KeyConstants._port, row, Caster.toString(HTTPUtil.getPort(task.getUrl())));
query.setAt("interval", row, task.getStringInterval());
query.setAt("timeout", row, Caster.toString(task.getTimeout() / 1000));
query.setAt("valid", row, Caster.toString(task.isValid()));
if (task.hasCredentials()) {
query.setAt("username", row, task.getCredentials().getUsername());
query.setAt("password", row, task.getCredentials().getPassword());
}
ProxyData pd = task.getProxyData();
if (ProxyDataImpl.isValid(pd)) {
query.setAt("proxyserver", row, pd.getServer());
if (pd.getPort() > 0) query.setAt("proxyport", row, Caster.toString(pd.getPort()));
if (ProxyDataImpl.hasCredentials(pd)) {
query.setAt("proxyuser", row, pd.getUsername());
query.setAt("proxypassword", row, pd.getPassword());
}
}
query.setAt("resolveurl", row, Caster.toString(task.isResolveURL()));
query.setAt("paused", row, Caster.toBoolean(task.isPaused()));
query.setAt("autoDelete", row, Caster.toBoolean(((ScheduleTaskImpl) task).isAutoDelete()));
}
pageContext.setVariable(returnvariable, query);
} catch (DatabaseException e) {
}
}