/**
* Create a new WebResults object.
*
* @param pathQuery used to get the paths of the columns
* @param results the underlying Results object
* @param im intermine API
* @param pathToQueryNode the mapping between Paths (in the columnPaths argument) and the
* QueryNodes in the results object
* @param pathToBagQueryResult a Map containing results from LOOKUP operations
*/
public WebResults(
InterMineAPI im,
PathQuery pathQuery,
Results results,
Map<String, QuerySelectable> pathToQueryNode,
Map<String, BagQueryResult> pathToBagQueryResult) {
this.im = im;
this.osResults = results;
this.flatResults = new ResultsFlatOuterJoinsImpl(((List) osResults), osResults.getQuery());
model = im.getModel();
this.columnPaths = new ArrayList<Path>();
try {
for (String pathString : pathQuery.getView()) {
this.columnPaths.add(pathQuery.makePath(pathString));
}
} catch (PathException e) {
throw new RuntimeException("Error creating WebResults because PathQuery is invalid", e);
}
classKeys = im.getClassKeys();
this.pathToQueryNode = new HashMap<String, QuerySelectable>();
if (pathToQueryNode != null) {
this.pathToQueryNode.putAll(pathToQueryNode);
}
this.pathToBagQueryResult = new HashMap<String, BagQueryResult>();
if (pathToBagQueryResult != null) {
this.pathToBagQueryResult.putAll(pathToBagQueryResult);
}
this.pathQuery = pathQuery;
pathToIndex = getPathToIndex();
redirector = im.getLinkRedirector();
addColumnsInternal(columnPaths);
}
/** {@inheritDoc} */
@Override
public ActionForward execute(
@SuppressWarnings("unused") ActionMapping mapping,
@SuppressWarnings("unused") ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
ObjectStore os = im.getObjectStore();
WebConfig webConfig = SessionMethods.getWebConfig(request);
Integer objectId = new Integer(request.getParameter("object"));
String fieldName = request.getParameter("field");
String fileType = request.getParameter("type");
InterMineObject object = os.getObjectById(objectId);
FieldExporter fieldExporter = null;
Set classes = DynamicUtil.decomposeClass(object.getClass());
Iterator classIter = classes.iterator();
while (classIter.hasNext()) {
Class c = (Class) classIter.next();
Type thisTypeConfig = webConfig.getTypes().get(c.getName());
FieldConfig fc = thisTypeConfig.getFieldConfigMap().get(fieldName);
if (fc != null) {
String fieldExporterClassName = fc.getFieldExporter();
if (fieldExporterClassName != null) {
fieldExporter = (FieldExporter) Class.forName(fieldExporterClassName).newInstance();
break;
}
}
}
if (fieldExporter == null) {
Object fieldValue = object.getFieldValue(fieldName);
if (fileType == null || fileType.length() == 0) {
response.setContentType("text/plain; charset=UTF-8");
response.setHeader("Content-Disposition ", "inline; filename=" + fieldName + ".txt");
} else {
response.setContentType("text/" + fileType);
response.setHeader(
"Content-Disposition ", "inline; filename=" + fieldName + "." + fileType);
}
PrintStream out = new PrintStream(response.getOutputStream());
if (fieldValue instanceof ClobAccess) {
((ClobAccess) fieldValue).drainToPrintStream(out);
} else {
out.print(fieldValue);
}
out.flush();
} else {
fieldExporter.exportField(object, fieldName, os, response);
}
return null;
}
/**
* Save a single object to an existing bag.
*
* @param mapping The ActionMapping used to select this instance
* @param form The optional ActionForm bean for this request (if any)
* @param request The HTTP request we are processing
* @param response The HTTP response we are creating
* @return an ActionForward object defining where control goes next
*/
@Override
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
int id = Integer.parseInt(request.getParameter("object"));
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(request.getSession());
Profile profile = SessionMethods.getProfile(session);
String bagName = request.getParameter("bag");
InterMineBag existingBag = profile.getSavedBags().get(bagName);
if (existingBag != null) {
// TODO add a warning when object already in bag ??
try {
InterMineObject o = im.getObjectStore().getObjectById(id);
existingBag.addIdToBag(id, DynamicUtil.getFriendlyName(o.getClass()));
recordMessage(new ActionMessage("bag.addedToBag", existingBag.getName()), request);
} catch (IncompatibleTypesException e) {
recordError(new ActionMessage("bag.typesDontMatch"), request);
} catch (ObjectStoreException e) {
recordError(new ActionMessage("bag.error"), request, e);
}
} else {
recordError(new ActionMessage("bag.noSuchBag"), request);
}
return mapping.findForward("report");
}
/** {@inheritDoc} */
public ActionForward execute(
@SuppressWarnings("unused") ActionMapping mapping,
@SuppressWarnings("unused") ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
String type = request.getParameter("type");
if (type == null) {
type = "webapp";
}
if ("webapp".equals(type)) {
response.getOutputStream().print("OK");
} else if ("query".equals(type)) {
final InterMineAPI im = SessionMethods.getInterMineAPI(request.getSession());
ObjectStore os = im.getObjectStore();
Query q = new Query();
QueryClass c = new QueryClass(InterMineObject.class);
q.addFrom(c);
q.addToSelect(c);
// Add a unique value to the select to avoid caching the query
QueryValue token = new QueryValue(System.currentTimeMillis());
q.addToSelect(token);
Results r = os.execute(q, 1, false, false, false);
if (r.get(0) != null) {
response.getOutputStream().print("OK");
} else {
response.getOutputStream().print("NO RESULTS");
}
}
return null;
}
/**
* Constructor with necessary objects to generate an ObjectStore query from a PathQuery and
* execute it.
*
* @param im intermine API
* @param profile the user executing the query - for access to saved lists
*/
public WebResultsExecutor(InterMineAPI im, Profile profile) {
os = im.getObjectStore();
bagQueryRunner = im.getBagQueryRunner();
this.profile = profile;
this.im = im;
bagManager = im.getBagManager();
this.summaryBatchSize = Constants.BATCH_SIZE;
}
@SuppressWarnings("unchecked")
@Override
public void display(HttpServletRequest request, ReportObject reportObject) {
// get the gene/protein in question from the request
InterMineObject object = reportObject.getObject();
// wrapper for the result so we can say what type it is
HashMap<String, Object> result = new HashMap();
// API connection
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Model model = im.getModel();
PathQuery query = new PathQuery(model);
// dealing with genes...
if (object instanceof Gene) {
// cast me Gene
Gene gene = (Gene) object;
String geneID = String.valueOf(gene.getId());
query = geneCommentsQuery(geneID, query);
Profile profile = SessionMethods.getProfile(session);
PathQueryExecutor executor = im.getPathQueryExecutor(profile);
ExportResultsIterator values;
try {
values = executor.execute(query);
} catch (ObjectStoreException e) {
throw new RuntimeException(e);
}
result.put("gene", geneComments2(values));
// result.put("gene", geneComments(gene));
} else if (object instanceof Protein) {
// cast me Protein
Protein protein = (Protein) object;
String proteinID = String.valueOf(protein.getId());
query = proteinCommentsQuery(proteinID, query);
Profile profile = SessionMethods.getProfile(session);
PathQueryExecutor executor = im.getPathQueryExecutor(profile);
ExportResultsIterator values;
try {
values = executor.execute(query);
} catch (ObjectStoreException e) {
throw new RuntimeException(e);
}
result.put("protein", proteinComments2(values));
// result.put("protein", proteinComments(protein));
} else {
// big fat fail
}
request.setAttribute("response", result);
}
/**
* @param pt paged table
* @param request request
* @return all results of pathquery corresponding specified paged table.
*/
public ExportResultsIterator getResultRows(PagedTable pt, HttpServletRequest request) {
PathQuery pathQuery = pt.getWebTable().getPathQuery();
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Profile profile = SessionMethods.getProfile(session);
executor = im.getPathQueryExecutor(profile);
executor.setBatchSize(BATCH_SIZE);
return executor.execute(pathQuery);
}
private void doMatches(Map<String, Object> ret, BagQueryResult bqr) {
for (Entry<Integer, List> pair : bqr.getMatches().entrySet()) {
Map<String, Object> resultItem;
InterMineObject imo;
try {
imo = im.getObjectStore().getObjectById(pair.getKey());
} catch (ObjectStoreException e) {
throw new IllegalStateException("Could not retrieve object reported as match", e);
}
String idKey = String.valueOf(imo.getId());
if (ret.containsKey(idKey)) {
resultItem = (Map<String, Object>) ret.get(idKey);
} else {
resultItem = new HashMap<String, Object>();
resultItem.put("identifiers", new HashMap<String, Object>());
}
if (!resultItem.containsKey("summary")) {
resultItem.put("summary", getObjectDetails(imo));
}
Map<String, Object> identifiers = (Map<String, Object>) resultItem.get("identifiers");
for (Object o : pair.getValue()) {
String ident = (String) o;
if (!identifiers.containsKey(ident)) {
identifiers.put(ident, new HashSet<String>());
}
Set<String> categories = (Set<String>) identifiers.get(ident);
categories.add("MATCH");
}
String className = DynamicUtil.getSimpleClassName(imo.getClass());
resultItem.put("type", className.replaceAll("^.*\\.", ""));
ret.put(idKey, resultItem);
}
}
/** @param im The InterMine state object * */
public TableCellFormatter(InterMineAPI im) {
this.im = im;
this.maxCellLength =
Integer.valueOf(
InterMineContext.getWebProperties()
.getProperty("webservice.tablecellformatter.cell.length.max", "200"));
this.redirector = im.getLinkRedirector();
}
/** {@inheritDoc} */
@Override
public ActionForward execute(
ComponentContext context,
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
InterMineBag imBag = (InterMineBag) request.getAttribute("bag");
WebConfig webConfig = SessionMethods.getWebConfig(request);
Model model = im.getModel();
TemplateManager templateManager = im.getTemplateManager();
Map<Class, ApiTemplate> conversionTypesMap =
TypeConverter.getConversionTemplates(
templateManager.getConversionTemplates(),
TypeUtil.instantiate(model.getPackageName() + "." + imBag.getType()));
ArrayList<String> conversionTypes = new ArrayList<String>();
Map<Type, Boolean> fastaMap = new HashMap<Type, Boolean>();
for (Class<?> clazz : conversionTypesMap.keySet()) {
conversionTypes.add(TypeUtil.unqualifiedName(clazz.getName()));
Type type = webConfig.getTypes().get(clazz.getName());
FieldConfig fieldConfig = type.getFieldConfigMap().get("length");
if (fieldConfig != null && fieldConfig.getDisplayer() != null) {
fastaMap.put(type, Boolean.TRUE);
} else {
fastaMap.put(type, Boolean.FALSE);
}
}
// Use custom converters
BagQueryConfig bagQueryConfig = im.getBagQueryConfig();
String bagType = imBag.getType();
Set<AdditionalConverter> additionalConverters = bagQueryConfig.getAdditionalConverters(bagType);
request.setAttribute("customConverters", additionalConverters);
request.setAttribute("conversionTypes", conversionTypes);
request.setAttribute("fastaMap", fastaMap);
return null;
}
/** {@inheritDoc} */
public ActionForward execute(
ComponentContext context,
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
String name = (String) context.getAttribute("name");
String type = (String) context.getAttribute("type");
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Profile profile = SessionMethods.getProfile(session);
TagManager tagManager = im.getTagManager();
Set<String> userTags = tagManager.getObjectTagNames(name, type, profile.getUsername());
String isFavourite = Boolean.toString(userTags.contains(TagNames.IM_FAVOURITE));
request.setAttribute("isFavourite", isFavourite);
return null;
}
/**
* Method called when user has finished updating a constraint.
*
* @param mapping The ActionMapping used to select this instance
* @param form The optional ActionForm bean for this request (if any)
* @param request The HTTP request we are processing
* @param response The HTTP response we are creating
* @return an ActionForward object defining where control goes next
* @exception Exception if the application business logic throws an exception
*/
@Override
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
ProfileManager pm = im.getProfileManager();
String username = ((CreateAccountForm) form).getUsername();
String password = ((CreateAccountForm) form).getPassword();
pm.createNewProfile(username, password);
Properties webProperties = SessionMethods.getWebProperties(session.getServletContext());
try {
MailUtils.email(username, webProperties);
if (((CreateAccountForm) form).getMailinglist()
&& webProperties.getProperty("mail.mailing-list") != null
&& webProperties.getProperty("mail.mailing-list").length() > 0) {
MailUtils.subscribe(username, webProperties);
}
SessionMethods.recordMessage(
"You have successfully created an account, and logged in.", session);
} catch (Exception e) {
SessionMethods.recordError("Failed to send confirmation email", session);
}
/*
* This code generates an MD5 key for the given username which is then
* encoded in Hexadecimal. This could later be used for account
* activation.
*
* try { MessageDigest md5 = MessageDigest.getInstance("MD5"); byte[]
* buffer = username.getBytes(); md5.update(buffer); byte[] array =
* md5.digest(); String encoded = HexBin.encode(array); } catch
* (NoSuchAlgorithmException e) { }
*/
doLogin(request, username, password);
return new ActionForward("/begin.do");
}
private InterMineObject getRequestedObject(InterMineAPI im, HttpServletRequest request) {
String idString = request.getParameter("id");
Integer id = new Integer(Integer.parseInt(idString));
ObjectStore os = im.getObjectStore();
InterMineObject requestedObject = null;
try {
requestedObject = os.getObjectById(id);
} catch (ObjectStoreException e) {
Log.warn("Accessed report page with id: " + id + " but failed to find object.", e);
}
return requestedObject;
}
private void doDuplicates(final Map<String, Object> ret, BagQueryResult bqr, String key) {
Map<String, Map<String, List>> issues = bqr.getIssues().get(key);
if (issues == null) {
return;
}
for (Map<String, List> issueSet : issues.values()) {
for (Entry<String, List> identToObjects : issueSet.entrySet()) {
String ident = identToObjects.getKey();
for (Object o : identToObjects.getValue()) {
InterMineObject imo;
Map<String, Object> resultItem;
if (o instanceof Integer) {
try {
imo = im.getObjectStore().getObjectById((Integer) o);
} catch (ObjectStoreException e) {
throw new IllegalStateException("Could not retrieve object reported as match", e);
}
} else if (o instanceof ConvertedObjectPair) {
imo = ((ConvertedObjectPair) o).getNewObject();
} else {
imo = (InterMineObject) o;
}
String idKey = String.valueOf(imo.getId());
if (ret.containsKey(idKey)) {
resultItem = (Map<String, Object>) ret.get(idKey);
} else {
resultItem = new HashMap<String, Object>();
resultItem.put("identifiers", new HashMap<String, Object>());
}
if (!resultItem.containsKey("summary")) {
resultItem.put("summary", getObjectDetails(imo));
}
Map<String, Object> identifiers = (Map<String, Object>) resultItem.get("identifiers");
if (!identifiers.containsKey(ident)) {
identifiers.put(ident, new HashSet<String>());
}
Set<String> categories = (Set<String>) identifiers.get(ident);
categories.add(key);
String className = DynamicUtil.getSimpleClassName(imo.getClass());
resultItem.put("type", className.replaceAll("^.*\\.", ""));
ret.put(idKey, resultItem);
}
}
}
}
private Map<String, Object> getObjectDetails(InterMineObject imo) {
WebConfig webConfig = InterMineContext.getWebConfig();
Model m = im.getModel();
Map<String, Object> objectDetails = new HashMap<String, Object>();
String className = DynamicUtil.getSimpleClassName(imo.getClass());
ClassDescriptor cd = m.getClassDescriptorByName(className);
for (FieldConfig fc : FieldConfigHelper.getClassFieldConfigs(webConfig, cd)) {
try {
Path p = new Path(m, cd.getUnqualifiedName() + "." + fc.getFieldExpr());
if (p.endIsAttribute() && fc.getShowInSummary()) {
objectDetails.put(
p.getNoConstraintsString().replaceAll("^[^.]*\\.", ""), PathUtil.resolvePath(p, imo));
}
} catch (PathException e) {
LOG.error(e);
}
}
return objectDetails;
}
/**
* Forward to the correct method based on the button pressed
*
* @param mapping The ActionMapping used to select this instance
* @param form The optional ActionForm bean for this request (if any)
* @param request The HTTP request we are processing
* @param response The HTTP response we are creating
* @return an ActionForward object defining where control goes next
* @exception Exception if the application business logic throws an exception
*/
@Override
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Profile profile = SessionMethods.getProfile(session);
Model model = im.getModel();
ModifyBagDetailsForm mbdf = (ModifyBagDetailsForm) form;
BagManager bagManager = im.getBagManager();
InterMineBag imBag = bagManager.getBag(profile, mbdf.getBagName());
String bagIdentifier = "bag." + imBag.getName();
if (request.getParameter("removeFromBag") != null) {
PagedTable pc = SessionMethods.getResultsTable(session, bagIdentifier);
String msg = "";
if (pc.isAllRowsSelected()) {
// TODO these messages need to be moved to properties file
msg = "You can't remove all items from your list. Try deleting your list instead.";
} else {
int removed = pc.removeSelectedFromBag(imBag, session);
msg = "You have removed " + removed + " items from your list.";
}
SessionMethods.recordMessage(msg, session);
// return new ForwardParameters(mapping.findForward("bagDetails"))
// .addParameter("bagName", mbdf.getBagName()).forward();
// pass an extra parameter telling the JSP to open up the results table
return new ForwardParameters(mapping.findForward("bagDetails"))
.addParameter("bagName", mbdf.getBagName())
.addParameter("table", "open")
.forward();
} else if (request.getParameter("addToBag") != null) {
InterMineBag newBag = bagManager.getBag(profile, mbdf.getExistingBagName());
String msg = "";
if (newBag.getType().equals(imBag.getType())) {
PagedTable pc = SessionMethods.getResultsTable(session, bagIdentifier);
int oldSize = newBag.size();
pc.addSelectedToBag(newBag);
int newSize = newBag.size();
int added = newSize - oldSize;
msg =
"You have added "
+ added
+ " items from list <strong>"
+ imBag.getName()
+ "</strong> to list <strong>"
+ newBag.getName()
+ "</strong>";
} else {
msg = "You can only add objects to other lists of the same type";
}
SessionMethods.recordMessage(msg, session);
// orthologues form
} else if (request.getParameter("convertToThing") != null) {
BagQueryConfig bagQueryConfig = im.getBagQueryConfig();
Set<AdditionalConverter> additionalConverters =
bagQueryConfig.getAdditionalConverters(imBag.getType());
if (additionalConverters != null && !additionalConverters.isEmpty()) {
for (AdditionalConverter additionalConverter : additionalConverters) {
BagConverter bagConverter =
PortalHelper.getBagConverter(
im, SessionMethods.getWebConfig(request), additionalConverter.getClassName());
List<Integer> converted =
bagConverter.getConvertedObjectIds(
profile, imBag.getType(), imBag.getContentsAsIds(), mbdf.getExtraFieldValue());
if (converted.size() == 1) {
return goToReport(mapping, converted.get(0).toString());
}
String bagName =
NameUtil.generateNewName(
profile.getSavedBags().keySet(),
mbdf.getExtraFieldValue() + " orthologues of " + imBag.getName());
InterMineBag newBag = profile.createBag(bagName, imBag.getType(), "", im.getClassKeys());
return createBagAndGoToBagDetails(mapping, newBag, converted);
}
}
// "use in bag" link
} else if (request.getParameter("useBag") != null) {
PagedTable pc = SessionMethods.getResultsTable(session, bagIdentifier);
PathQuery pathQuery = pc.getWebTable().getPathQuery().clone();
SessionMethods.setQuery(session, pathQuery);
session.setAttribute("path", imBag.getType());
session.setAttribute("prefix", imBag.getType());
String msg = "You can now create a query using your list " + imBag.getName();
SessionMethods.recordMessage(msg, session);
return mapping.findForward("query");
// convert links
} else if (request.getParameter("convert") != null && request.getParameter("bagName") != null) {
String type2 = request.getParameter("convert");
TemplateManager templateManager = im.getTemplateManager();
PathQuery q =
BagConversionHelper.getConvertedObjects(
session,
templateManager.getConversionTemplates(),
TypeUtil.instantiate(model.getPackageName() + "." + imBag.getType()),
TypeUtil.instantiate(model.getPackageName() + "." + type2),
imBag);
q.setTitle(type2 + "s from list '" + imBag.getName() + "'");
SessionMethods.loadQuery(q, session, response);
String qid = SessionMethods.startQueryWithTimeout(request, false, q);
Thread.sleep(200); // slight pause in the hope of avoiding holding page
final String trail = "|bag." + imBag.getName();
return new ForwardParameters(mapping.findForward("waiting"))
.addParameter("trail", trail)
.addParameter("qid", qid)
.forward();
}
return new ForwardParameters(mapping.findForward("bagDetails"))
.addParameter("bagName", mbdf.getBagName())
.forward();
}
public TrackAjaxServices() {
HttpSession session = WebContextFactory.get().getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
uos = im.getProfileManager().getProfileObjectStoreWriter().getObjectStore();
}
private void unshareBag(HttpSession session, Profile profile, InterMineBag bag) {
InterMineAPI api = SessionMethods.getInterMineAPI(session);
BagManager bm = api.getBagManager();
bm.unshareBagWithUser(bag, profile);
}
/**
* Method called to export a saved Query.
*
* @param mapping The ActionMapping used to select this instance
* @param form The optional ActionForm bean for this request (if any)
* @param request The HTTP request we are processing
* @param response The HTTP response we are creating
* @return an ActionForward object defining where control goes next
* @exception Exception if the application business logic throws an exception
*/
@Override
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Profile profile = SessionMethods.getProfile(session);
String type = request.getParameter("type");
String name = request.getParameter("name");
PathQuery query = null;
if (StringUtils.isEmpty(type) || StringUtils.isEmpty(name)) {
query = SessionMethods.getQuery(session);
} else if ("history".equals(type)) {
SavedQuery sq = profile.getHistory().get(name);
if (sq == null) {
recordError(new ActionMessage("errors.query.missing", name), request);
return mapping.findForward("mymine");
}
query = sq.getPathQuery();
} else if ("saved".equals(type)) {
SavedQuery sq = profile.getSavedQueries().get(name);
if (sq == null) {
recordError(new ActionMessage("errors.query.missing", name), request);
return mapping.findForward("mymine");
}
query = sq.getPathQuery();
} else {
LOG.error("Bad type parameter: " + type);
return null;
}
if (query == null) {
LOG.error("Failed to find query " + name + " of type " + type);
return null;
}
if (query.getView().size() == 0) {
response.getWriter().write("Invalid query. No fields selected for output.");
return null;
}
response.setContentType("text/plain; charset=utf-8");
WebResultsExecutor webResultsExecutor = im.getWebResultsExecutor(profile);
String format;
if (!StringUtils.isEmpty(request.getParameter("as"))) {
format = request.getParameter("as").toLowerCase();
} else {
format = "xml";
}
if ("xml".equals(format)) {
String xml = getQueryXML(name, query);
xml = XmlUtil.indentXmlSimple(xml);
response.getWriter().write(xml);
} else if ("iql".equals(format)) {
Query osQuery = webResultsExecutor.makeQuery(query);
response.getWriter().println(osQuery.toString());
} else if ("sql".equals(format)) {
response.getWriter().println(webResultsExecutor.makeSql(query));
} else if ("link".equals(format)) {
String serviceFormat;
if (request.getParameter("serviceFormat") != null) {
serviceFormat = request.getParameter("serviceFormat");
} else {
serviceFormat = "tab";
}
String xml = getQueryXML(name, query);
String link =
new QueryResultLinkGenerator()
.getLink(new URLGenerator(request).getPermanentBaseURL(), xml, serviceFormat);
response.getWriter().write(link);
} else {
response.getWriter().println("Unknown export type: " + request.getParameter("as"));
}
return null;
}
private void copy(ActionForm form, HttpServletRequest request) throws ObjectStoreException {
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Profile profile = SessionMethods.getProfile(session);
ModifyBagForm frm = (ModifyBagForm) form;
String[] selectedBagNames = frm.getSelectedBags();
BagManager bagManager = im.getBagManager();
Map<String, InterMineBag> allBags = bagManager.getBags(profile);
String newNameTextBox = getNewNameTextBox(request, frm.getNewBagName());
if (selectedBagNames.length == 1) {
String selectedBagName = selectedBagNames[0];
InterMineBag origBag = allBags.get(selectedBagName);
if (origBag == null) {
recordError(new ActionMessage("errors.bag.notfound"), request);
return;
}
String newBagName = "";
if (newNameTextBox != null) {
newBagName = NameUtil.validateName(allBags.keySet(), newNameTextBox);
if (newBagName.isEmpty()) {
recordError(new ActionMessage("bag.createdlists.notvalidname", newNameTextBox), request);
return;
}
}
if (newNameTextBox == null) {
newBagName = NameUtil.generateNewName(allBags.keySet(), selectedBagName);
}
if (createBag(origBag, newBagName, profile)) {
recordMessage(new ActionMessage("bag.createdlists", newBagName), request);
// track the list creation
im.getTrackerDelegate()
.trackListCreation(
origBag.getType(),
origBag.getSize(),
ListBuildMode.OPERATION,
profile,
session.getId());
}
} else {
if (newNameTextBox != null) {
recordError(new ActionMessage("errors.bag.namecannotbespecified"), request);
return;
}
String msg = "";
for (int i = 0; i < selectedBagNames.length; i++) {
String selectedBagName = selectedBagNames[i];
InterMineBag origBag = allBags.get(selectedBagName);
if (origBag == null) {
recordError(new ActionMessage("errors.bag.notfound"), request);
return;
}
String newBagName = NameUtil.generateNewName(allBags.keySet(), selectedBagName);
if (createBag(origBag, newBagName, profile)) {
msg += newBagName + ", ";
}
}
if (msg.length() > 2) {
msg = msg.substring(0, msg.length() - 2);
}
if (msg.length() > 0) {
recordMessage(new ActionMessage("bag.createdlists", msg), request);
}
}
}
private void combine(ActionForm form, HttpServletRequest request, String opText) {
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Profile profile = SessionMethods.getProfile(session);
ModifyBagForm mbf = (ModifyBagForm) form;
BagManager bagManager = im.getBagManager();
Map<String, InterMineBag> allBags = bagManager.getBags(profile);
String[] selectedBagNames = mbf.getSelectedBags();
Collection<InterMineBag> selectedBags = getSelectedBags(allBags, selectedBagNames);
String newBagName = NameUtil.validateName(allBags.keySet(), mbf.getNewBagName());
int newBagSize = 0;
try {
if (opText.equals(BagOperations.UNION)) {
newBagSize = BagOperations.union(selectedBags, newBagName, profile, im.getClassKeys());
} else if (opText.equals(BagOperations.INTERSECT)) {
newBagSize = BagOperations.intersect(selectedBags, newBagName, profile, im.getClassKeys());
} else if (opText.equals(BagOperations.SUBTRACT)) {
newBagSize = BagOperations.subtract(selectedBags, newBagName, profile, im.getClassKeys());
}
} catch (IncompatibleTypesException e) {
SessionMethods.recordError(
"You can only perform operations on lists of the same type."
+ " Lists "
+ StringUtil.prettyList(Arrays.asList(selectedBagNames))
+ " do not match.",
session);
return;
} catch (ObjectStoreException e) {
LOG.error(e);
ActionMessage actionMessage = new ActionMessage("An error occurred while saving the list");
recordError(actionMessage, request);
return;
}
if (newBagSize > 0) {
SessionMethods.recordMessage(
"Created list \""
+ newBagName
+ "\" as "
+ opText
+ " of "
+ StringUtil.prettyList(Arrays.asList(selectedBagNames))
+ ".",
session);
// track the list creation
im.getTrackerDelegate()
.trackListCreation(
BagOperations.getCommonBagType(selectedBags),
newBagSize,
ListBuildMode.OPERATION,
profile,
session.getId());
} else {
SessionMethods.recordError(
opText
+ " operation on lists "
+ StringUtil.prettyList(Arrays.asList(selectedBagNames))
+ " produced no results.",
session);
}
}
/** {@inheritDoc} */
@SuppressWarnings("unused")
@Override
public ActionForward execute(
@SuppressWarnings("unused") ActionMapping mapping,
@SuppressWarnings("unused") ActionForm form,
HttpServletRequest request,
@SuppressWarnings("unused") HttpServletResponse response)
throws Exception {
long startTime = System.currentTimeMillis();
HttpSession session = request.getSession();
InterMineAPI im = SessionMethods.getInterMineAPI(session);
if (im.getBagManager().isAnyBagToUpgrade(SessionMethods.getProfile(session))) {
recordError(new ActionMessage("login.upgradeListManually"), request);
}
// fetch & set requested object
InterMineObject requestedObject = getRequestedObject(im, request);
if (requestedObject != null) {
ReportObjectFactory reportObjectFactory = SessionMethods.getReportObjects(session);
ReportObject reportObject = reportObjectFactory.get(requestedObject);
request.setAttribute("object", reportObject);
request.setAttribute("reportObject", reportObject);
request.setAttribute("requestedObject", requestedObject);
// hell starts here
TagManager tagManager = im.getTagManager();
ServletContext servletContext = session.getServletContext();
ObjectStore os = im.getObjectStore();
String superuser = im.getProfileManager().getSuperuser();
if (superuser.equals(SessionMethods.getProfile(session).getUsername())) {
request.setAttribute("SHOW_TAGS", true);
}
// place InlineLists based on TagManager, reportObject is cached while Controller is not
Map<String, List<InlineList>> placedInlineLists = new TreeMap<String, List<InlineList>>();
// traverse all unplaced (non-header) InlineLists
for (InlineList list : reportObject.getNormalInlineLists()) {
FieldDescriptor fd = list.getDescriptor();
String taggedType = getTaggedType(fd);
// assign lists to any aspects they are tagged to or put in unplaced lists
String fieldPath = fd.getClassDescriptor().getUnqualifiedName() + "." + fd.getName();
List<Tag> tags = tagManager.getTags(null, fieldPath, taggedType, superuser);
for (Tag tag : tags) {
String tagName = tag.getTagName();
if (AspectTagUtil.isAspectTag(tagName)) {
List<InlineList> listsForAspect = placedInlineLists.get(tagName);
if (listsForAspect == null) {
listsForAspect = new ArrayList<InlineList>();
placedInlineLists.put(tagName, listsForAspect);
}
listsForAspect.add(list);
} else if (tagName.equals(TagNames.IM_SUMMARY)) {
List<InlineList> summaryLists = placedInlineLists.get(tagName);
if (summaryLists == null) {
summaryLists = new ArrayList<InlineList>();
placedInlineLists.put(tagName, summaryLists);
}
summaryLists.add(list);
}
}
}
// any lists that aren't tagged will be 'unplaced'
List<InlineList> unplacedInlineLists =
new ArrayList<InlineList>(reportObject.getNormalInlineLists());
unplacedInlineLists.removeAll(placedInlineLists.values());
long now = System.currentTimeMillis();
LOG.info("TIME placed inline lists: " + (now - startTime) + "ms");
long stepTime = now;
request.setAttribute("mapOfInlineLists", placedInlineLists);
request.setAttribute("listOfUnplacedInlineLists", unplacedInlineLists);
Map<String, Map<String, DisplayField>> placementRefsAndCollections =
new TreeMap<String, Map<String, DisplayField>>();
Set<String> aspects = new LinkedHashSet<String>(SessionMethods.getCategories(servletContext));
Set<ClassDescriptor> cds =
os.getModel().getClassDescriptorsForClass(requestedObject.getClass());
for (String aspect : aspects) {
placementRefsAndCollections.put(
TagNames.IM_ASPECT_PREFIX + aspect,
new TreeMap<String, DisplayField>(String.CASE_INSENSITIVE_ORDER));
}
Map<String, DisplayField> miscRefs =
new TreeMap<String, DisplayField>(reportObject.getRefsAndCollections());
placementRefsAndCollections.put(TagNames.IM_ASPECT_MISC, miscRefs);
// summary refs and colls
Map<String, DisplayField> summaryRefsCols = new TreeMap<String, DisplayField>();
placementRefsAndCollections.put(TagNames.IM_SUMMARY, summaryRefsCols);
for (Iterator<Entry<String, DisplayField>> iter =
reportObject.getRefsAndCollections().entrySet().iterator();
iter.hasNext(); ) {
Map.Entry<String, DisplayField> entry = iter.next();
DisplayField df = entry.getValue();
if (df instanceof DisplayReference) {
categoriseBasedOnTags(
((DisplayReference) df).getDescriptor(),
"reference",
df,
miscRefs,
tagManager,
superuser,
placementRefsAndCollections,
SessionMethods.isSuperUser(session));
} else if (df instanceof DisplayCollection) {
categoriseBasedOnTags(
((DisplayCollection) df).getDescriptor(),
"collection",
df,
miscRefs,
tagManager,
superuser,
placementRefsAndCollections,
SessionMethods.isSuperUser(session));
}
}
// remove any fields overridden by displayers
removeFieldsReplacedByReportDisplayers(reportObject, placementRefsAndCollections);
request.setAttribute("placementRefsAndCollections", placementRefsAndCollections);
String type = reportObject.getType();
request.setAttribute("objectType", type);
String stableLink = PortalHelper.generatePortalLink(reportObject.getObject(), im, request);
if (stableLink != null) {
request.setAttribute("stableLink", stableLink);
}
stepTime = System.currentTimeMillis();
startTime = stepTime;
// attach only non empty categories
Set<String> allClasses = new HashSet<String>();
for (ClassDescriptor cld : cds) {
allClasses.add(cld.getUnqualifiedName());
}
TemplateManager templateManager = im.getTemplateManager();
Map<String, List<ReportDisplayer>> displayerMap = reportObject.getReportDisplayers();
stepTime = System.currentTimeMillis();
startTime = stepTime;
List<String> categories = new LinkedList<String>();
for (String aspect : aspects) {
// 1) Displayers
// 2) Inline Lists
if ((displayerMap != null && displayerMap.containsKey(aspect))
|| placedInlineLists.containsKey(aspect)) {
categories.add(aspect);
} else {
// 3) Templates
if (!templateManager.getReportPageTemplatesForAspect(aspect, allClasses).isEmpty()) {
categories.add(aspect);
} else {
// 4) References & Collections
if (placementRefsAndCollections.containsKey("im:aspect:" + aspect)
&& placementRefsAndCollections.get("im:aspect:" + aspect) != null) {
for (DisplayField df :
placementRefsAndCollections.get("im:aspect:" + aspect).values()) {
categories.add(aspect);
break;
}
}
}
}
}
if (!categories.isEmpty()) {
request.setAttribute("categories", categories);
}
now = System.currentTimeMillis();
LOG.info("TIME made list of categories: " + (now - stepTime) + "ms");
}
return null;
}
/** {@inheritDoc} */
@Override
public ActionForward execute(
ComponentContext context,
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
boolean canExportAsBED = false;
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Model model = im.getModel();
PathQuery query = new PathQuery(model);
// org and dbkey for galaxy use
Set<String> orgSet = new HashSet<String>();
Set<String> genomeBuildSet = new HashSet<String>();
// Build GenomicRegion pathquery, the request is from GenomicRegionSearch "export to Galaxy"
if (request.getParameter("featureIds") != null) {
String featureIds = request.getParameter("featureIds").trim();
String orgName = request.getParameter("orgName");
if (orgName != null && !"".equals(orgName)) {
orgSet.add(orgName);
}
// Refer to GenomicRegionSearchService.getExportFeaturesQuery method
String path = "SequenceFeature";
query.addView(path + ".primaryIdentifier");
query.addView(path + ".chromosomeLocation.locatedOn.primaryIdentifier");
query.addView(path + ".chromosomeLocation.start");
query.addView(path + ".chromosomeLocation.end");
query.addView(path + ".organism.name");
// use ids or pids
String[] idsInStr = featureIds.split(",");
Set<Integer> ids = new HashSet<Integer>();
boolean isIds = true;
for (String id : idsInStr) {
id = id.trim();
if (!Pattern.matches("^\\d+$", id)) {
isIds = false;
break;
}
ids.add(Integer.valueOf(id));
}
if (isIds) {
query.addConstraint(Constraints.inIds(path, ids));
} else {
if (featureIds.contains("'")) {
featureIds = featureIds.replaceAll("'", "\\\\'");
}
query.addConstraint(Constraints.lookup(path, featureIds, null));
}
canExportAsBED = true;
} else { // request from normal result table
String tableName = request.getParameter("table");
request.setAttribute("table", tableName);
PagedTable pt = SessionMethods.getResultsTable(session, tableName);
// Null check to page table, maybe session timeout?
if (pt == null) {
LOG.error("Page table is NULL...");
return null;
}
// Check if can export as BED
TableHttpExporter tableExporter = new BEDHttpExporter();
try {
canExportAsBED = tableExporter.canExport(pt);
} catch (Exception e) {
canExportAsBED = false;
LOG.error("Caught an error running canExport() for: BEDHttpExporter. " + e);
e.printStackTrace();
}
LinkedHashMap<Path, Integer> exportClassPathsMap = getExportClassPaths(pt);
List<Path> exportClassPaths = new ArrayList<Path>(exportClassPathsMap.keySet());
Map<String, String> pathMap = new LinkedHashMap<String, String>();
for (Path path : exportClassPaths) {
String pathString = path.toStringNoConstraints();
String displayPath = pathString.replace(".", " > ");
pathMap.put(pathString, displayPath);
}
Map<String, Integer> pathIndexMap = new LinkedHashMap<String, Integer>();
for (int index = 0; index < exportClassPaths.size(); index++) {
String pathString = exportClassPaths.get(index).toStringNoConstraints();
Integer idx = exportClassPathsMap.get(exportClassPaths.get(index));
pathIndexMap.put(pathString, idx);
}
request.setAttribute("exportClassPaths", pathMap);
request.setAttribute("pathIndexMap", pathIndexMap);
// Support export public and private lists to Galaxy
query = pt.getWebTable().getPathQuery();
ObjectStore os = im.getObjectStore();
Map<PathConstraint, String> constrains = query.getConstraints();
for (PathConstraint constraint : constrains.keySet()) {
if (constraint instanceof PathConstraintBag) {
String bagName = ((PathConstraintBag) constraint).getBag();
InterMineBag imBag =
im.getBagManager().getBag(SessionMethods.getProfile(session), bagName);
// find the classKeys
Set<String> classKeySet = new LinkedHashSet<String>();
for (Integer id : imBag.getContentsAsIds()) {
String classKey = pt.findClassKeyValue(im.getClassKeys(), os.getObjectById(id));
classKeySet.add(classKey);
}
String path = ((PathConstraintBag) constraint).getPath();
// replace constraint in the pathquery
PathConstraintLookup newConstraint =
new PathConstraintLookup(
path,
classKeySet.toString().substring(1, classKeySet.toString().length() - 1),
null);
query.replaceConstraint(constraint, newConstraint);
}
}
orgSet = SequenceFeatureExportUtil.getOrganisms(query, session);
}
if (query instanceof TemplateQuery) {
TemplateQuery templateQuery = (TemplateQuery) query;
Map<PathConstraint, SwitchOffAbility> constraintSwitchOffAbilityMap =
templateQuery.getConstraintSwitchOffAbility();
for (Map.Entry<PathConstraint, SwitchOffAbility> entry :
constraintSwitchOffAbilityMap.entrySet()) {
if (entry.getValue().compareTo(SwitchOffAbility.OFF) == 0) {
templateQuery.removeConstraint(entry.getKey());
}
}
}
String queryXML =
PathQueryBinding.marshal(query, "", model.getName(), PathQuery.USERPROFILE_VERSION);
// String encodedQueryXML = URLEncoder.encode(queryXML, "UTF-8");
String tableViewURL =
new URLGenerator(request).getPermanentBaseURL() + "/service/query/results";
request.setAttribute("tableURL", tableViewURL);
request.setAttribute("queryXML", queryXML);
request.setAttribute("size", 1000000);
// If can export as BED
request.setAttribute("canExportAsBED", canExportAsBED);
if (canExportAsBED) {
String bedURL =
new URLGenerator(request).getPermanentBaseURL() + "/service/query/results/bed";
request.setAttribute("bedURL", bedURL);
genomeBuildSet =
(Set<String>) OrganismGenomeBuildLookup.getGenomeBuildByOrgansimCollection(orgSet);
String org =
(orgSet.size() < 1) ? "Organism information not available" : StringUtil.join(orgSet, ",");
// possible scenario: [null, ce3, null], should remove all null element and then join
genomeBuildSet.removeAll(Collections.singleton(null));
String dbkey =
(genomeBuildSet.size() < 1)
? "Genome Build information not available"
: StringUtil.join(genomeBuildSet, ",");
request.setAttribute("org", org);
request.setAttribute("dbkey", dbkey);
}
// PathMap
Map<String, String> pathsMap = new LinkedHashMap<String, String>();
List<String> views = query.getView();
for (String view : views) {
String title = query.getGeneratedPathDescription(view);
title = WebUtil.formatColumnName(title);
pathsMap.put(view, title);
}
request.setAttribute("pathsMap", pathsMap);
return null;
}
@Override
public void display(HttpServletRequest request, ReportObject reportObject) {
// get the gene/protein in question from the request
InterMineObject object = reportObject.getObject();
// API connection
HttpSession session = request.getSession();
final InterMineAPI im = SessionMethods.getInterMineAPI(session);
Model model = im.getModel();
PathQuery query = new PathQuery(model);
// cast me Gene
Gene gene = (Gene) object;
Object genePrimaryIDObj = gene.getPrimaryIdentifier();
if (genePrimaryIDObj != null) {
// fetch the expression
String genePrimaryID = String.valueOf(genePrimaryIDObj);
query = geneExpressionAtlasQuery(genePrimaryID, query);
// execute the query
Profile profile = SessionMethods.getProfile(session);
PathQueryExecutor executor = im.getPathQueryExecutor(profile);
ExportResultsIterator values = executor.execute(query);
// convert to a map
GeneExpressionAtlasDiseasesExpressions geae =
new GeneExpressionAtlasDiseasesExpressions(values);
// attach to results
request.setAttribute("expressions", geae);
request.setAttribute("url", "http://www.ebi.ac.uk/gxa/experiment/E-MTAB-62/" + genePrimaryID);
request.setAttribute("defaultPValue", "1e-4");
request.setAttribute("defaultTValue", "4");
// get the corresponding collection
for (FieldDescriptor fd : reportObject.getClassDescriptor().getAllFieldDescriptors()) {
if ("atlasExpression".equals(fd.getName()) && fd.isCollection()) {
// fetch the collection
Collection<?> collection = null;
try {
collection = (Collection<?>) reportObject.getObject().getFieldValue("atlasExpression");
} catch (IllegalAccessException e) {
e.printStackTrace();
}
List<Class<?>> lc =
PathQueryResultHelper.queryForTypesInCollection(
reportObject.getObject(), "atlasExpression", im.getObjectStore());
// create an InlineResultsTable
InlineResultsTable t =
new InlineResultsTable(
collection,
fd.getClassDescriptor().getModel(),
SessionMethods.getWebConfig(request),
im.getClassKeys(),
collection.size(),
false,
lc);
request.setAttribute("collection", t);
break;
}
}
}
}
/**
* Constructor
*
* @param im A reference to the main settings bundle
*/
public ListUploadService(final InterMineAPI im) {
super(im);
runner = im.getBagQueryRunner();
}
/** The method to run all the queries. */
@SuppressWarnings("rawtypes")
private void queryExecutor() {
// Use spanOverlapFullResultMap to store the data in the session
@SuppressWarnings("unchecked")
Map<String, Map<GenomicRegion, List<SpanQueryResultRow>>> spanOverlapFullResultMap =
(Map<String, Map<GenomicRegion, List<SpanQueryResultRow>>>)
request.getSession().getAttribute("spanOverlapFullResultMap");
if (spanOverlapFullResultMap == null) {
spanOverlapFullResultMap =
new HashMap<String, Map<GenomicRegion, List<SpanQueryResultRow>>>();
}
Map<GenomicRegion, List<SpanQueryResultRow>> spanOverlapResultDisplayMap =
Collections.synchronizedMap(new LinkedHashMap<GenomicRegion, List<SpanQueryResultRow>>());
// GBrowse track
@SuppressWarnings("unchecked")
Map<String, Map<GenomicRegion, LinkedHashMap<String, LinkedHashSet<GBrowseTrackInfo>>>>
gbrowseFullTrackMap =
(HashMap<
String,
Map<GenomicRegion, LinkedHashMap<String, LinkedHashSet<GBrowseTrackInfo>>>>)
request.getSession().getAttribute("gbrowseFullTrackMap");
if (gbrowseFullTrackMap == null) {
gbrowseFullTrackMap =
new HashMap<
String, Map<GenomicRegion, LinkedHashMap<String, LinkedHashSet<GBrowseTrackInfo>>>>();
}
Map<GenomicRegion, LinkedHashMap<String, LinkedHashSet<GBrowseTrackInfo>>> gbrowseTrackMap =
Collections.synchronizedMap(
new LinkedHashMap<
GenomicRegion, LinkedHashMap<String, LinkedHashSet<GBrowseTrackInfo>>>());
if (!spanOverlapFullResultMap.containsKey(spanUUIDString)) {
spanOverlapFullResultMap.put(spanUUIDString, spanOverlapResultDisplayMap);
request.getSession().setAttribute("spanOverlapFullResultMap", spanOverlapFullResultMap);
gbrowseFullTrackMap.put(spanUUIDString, gbrowseTrackMap);
request.getSession().setAttribute("gbrowseFullTrackMap", gbrowseFullTrackMap);
try {
Query q;
for (GenomicRegion aSpan : spanList) {
q = new Query();
q.setDistinct(true);
String chrPID = aSpan.getChr();
Integer start = aSpan.getStart();
Integer end = aSpan.getEnd();
/*
>>>>> TEST CODE <<<<<
LOG.info("OrgName: " + orgName);
LOG.info("chrPID: " + chrPID);
LOG.info("start: " + start);
LOG.info("end: " + end);
LOG.info("FeatureTypes: " + ftKeys);
LOG.info("Submissions: " + subKeys);
>>>>> TEST CODE <<<<<
*/
// DB tables
QueryClass qcOrg = new QueryClass(Organism.class);
QueryClass qcChr = new QueryClass(Chromosome.class);
QueryClass qcFeature = new QueryClass(SequenceFeature.class);
QueryClass qcLoc = new QueryClass(Location.class);
QueryClass qcSubmission = new QueryClass(Submission.class);
QueryField qfOrgName = new QueryField(qcOrg, "shortName");
QueryField qfChrPID = new QueryField(qcChr, "primaryIdentifier");
QueryField qfFeaturePID = new QueryField(qcFeature, "primaryIdentifier");
QueryField qfFeatureId = new QueryField(qcFeature, "id");
QueryField qfFeatureClass = new QueryField(qcFeature, "class");
QueryField qfSubmissionTitle = new QueryField(qcSubmission, "title");
QueryField qfSubmissionDCCid = new QueryField(qcSubmission, "DCCid");
QueryField qfChr = new QueryField(qcChr, "primaryIdentifier");
QueryField qfLocStart = new QueryField(qcLoc, "start");
QueryField qfLocEnd = new QueryField(qcLoc, "end");
q.addToSelect(qfFeatureId);
q.addToSelect(qfFeaturePID);
q.addToSelect(qfFeatureClass);
q.addToSelect(qfChr);
q.addToSelect(qfLocStart);
q.addToSelect(qfLocEnd);
q.addToSelect(qfSubmissionDCCid);
q.addToSelect(qfSubmissionTitle);
q.addFrom(qcChr);
q.addFrom(qcOrg);
q.addFrom(qcFeature);
q.addFrom(qcLoc);
q.addFrom(qcSubmission);
q.addToOrderBy(qfLocStart, "ascending");
ConstraintSet constraints = new ConstraintSet(ConstraintOp.AND);
q.setConstraint(constraints);
// SequenceFeature.organism = Organism
QueryObjectReference organism = new QueryObjectReference(qcFeature, "organism");
ContainsConstraint ccOrg = new ContainsConstraint(organism, ConstraintOp.CONTAINS, qcOrg);
constraints.addConstraint(ccOrg);
// Organism.name = orgName
SimpleConstraint scOrg =
new SimpleConstraint(qfOrgName, ConstraintOp.EQUALS, new QueryValue(orgName));
constraints.addConstraint(scOrg);
// Location.feature = SequenceFeature
QueryObjectReference locSubject = new QueryObjectReference(qcLoc, "feature");
ContainsConstraint ccLocSubject =
new ContainsConstraint(locSubject, ConstraintOp.CONTAINS, qcFeature);
constraints.addConstraint(ccLocSubject);
// Location.locatedOn = Chromosome
QueryObjectReference locObject = new QueryObjectReference(qcLoc, "locatedOn");
ContainsConstraint ccLocObject =
new ContainsConstraint(locObject, ConstraintOp.CONTAINS, qcChr);
constraints.addConstraint(ccLocObject);
// Chromosome.primaryIdentifier = chrPID
SimpleConstraint scChr =
new SimpleConstraint(qfChrPID, ConstraintOp.EQUALS, new QueryValue(chrPID));
constraints.addConstraint(scChr);
// SequenceFeature.submissions = Submission
QueryCollectionReference submission =
new QueryCollectionReference(qcFeature, "submissions");
ContainsConstraint ccSubmission =
new ContainsConstraint(submission, ConstraintOp.CONTAINS, qcSubmission);
constraints.addConstraint(ccSubmission);
// SequenceFeature.class in a list
constraints.addConstraint(new BagConstraint(qfFeatureClass, ConstraintOp.IN, ftKeys));
// Submission.CCDid in a list
constraints.addConstraint(new BagConstraint(qfSubmissionDCCid, ConstraintOp.IN, subKeys));
OverlapRange overlapInput =
new OverlapRange(new QueryValue(start), new QueryValue(end), locObject);
OverlapRange overlapFeature =
new OverlapRange(
new QueryField(qcLoc, "start"), new QueryField(qcLoc, "end"), locObject);
OverlapConstraint oc =
new OverlapConstraint(overlapInput, ConstraintOp.OVERLAPS, overlapFeature);
constraints.addConstraint(oc);
Results results = im.getObjectStore().execute(q);
/*
>>>>> TEST CODE <<<<<
LOG.info("Query: " + q.toString());
LOG.info("Result Size: " + results.size());
LOG.info("Result >>>>> " + results);
>>>>> TEST CODE <<<<<
*/
List<SpanQueryResultRow> spanResults = new ArrayList<SpanQueryResultRow>();
if (results == null || results.isEmpty()) {
spanOverlapResultDisplayMap.put(aSpan, null);
gbrowseTrackMap.put(aSpan, null);
} else {
for (Iterator<?> iter = results.iterator(); iter.hasNext(); ) {
ResultsRow<?> row = (ResultsRow<?>) iter.next();
SpanQueryResultRow aRow = new SpanQueryResultRow();
aRow.setFeatureId((Integer) row.get(0));
aRow.setFeaturePID((String) row.get(1));
aRow.setFeatureClass(((Class) row.get(2)).getSimpleName());
aRow.setChr((String) row.get(3));
aRow.setStart((Integer) row.get(4));
aRow.setEnd((Integer) row.get(5));
aRow.setSubDCCid((String) row.get(6));
aRow.setSubTitle((String) row.get(7));
spanResults.add(aRow);
}
spanOverlapResultDisplayMap.put(aSpan, spanResults);
gbrowseTrackMap.put(aSpan, getSubGbrowseTrack(spanResults)); // Gbrowse
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
private static void runSpanValidationQuery(InterMineAPI im) {
// a Map contains orgName and its chrInfo accordingly
// e.g. <D.Melanogaster, (D.Melanogaster, X, 5000)...>
chrInfoMap = new HashMap<String, List<ChromosomeInfo>>();
try {
Query q = new Query();
QueryClass qcOrg = new QueryClass(Organism.class);
QueryClass qcChr = new QueryClass(Chromosome.class);
// Result columns
QueryField qfOrgName = new QueryField(qcOrg, "shortName");
QueryField qfChrPID = new QueryField(qcChr, "primaryIdentifier");
QueryField qfChrLength = new QueryField(qcChr, "length");
// As in SQL SELECT ?,?,?
q.addToSelect(qfOrgName);
q.addToSelect(qfChrPID);
q.addToSelect(qfChrLength);
// As in SQL FROM ?,?
q.addFrom(qcChr);
q.addFrom(qcOrg);
// As in SQL WHERE ?
QueryObjectReference organism = new QueryObjectReference(qcChr, "organism");
ContainsConstraint ccOrg = new ContainsConstraint(organism, ConstraintOp.CONTAINS, qcOrg);
q.setConstraint(ccOrg);
Results results = im.getObjectStore().execute(q);
// a List contains all the chrInfo (organism, chrPID, length)
List<ChromosomeInfo> chrInfoList = new ArrayList<ChromosomeInfo>();
// a Set contains all the orgName
Set<String> orgSet = new HashSet<String>();
// Handle results
for (Iterator<?> iter = results.iterator(); iter.hasNext(); ) {
ResultsRow<?> row = (ResultsRow<?>) iter.next();
String org = (String) row.get(0);
String chrPID = (String) row.get(1);
Integer chrLength = (Integer) row.get(2);
// Add orgName to HashSet to filter out duplication
orgSet.add(org);
if (chrLength != null) {
ChromosomeInfo chrInfo = new ChromosomeInfo();
chrInfo.setOrgName(org);
chrInfo.setChrPID(chrPID);
chrInfo.setChrLength(chrLength);
// Add ChromosomeInfo to Arraylist
chrInfoList.add(chrInfo);
}
}
// Iterate orgSet and chrInfoList to put data in chrInfoMap which has the key as the
// orgName and value as a ArrayList containing a list of chrInfo which has the same
// orgName
for (String o : orgSet) {
// a List to store chrInfo for the same organism
List<ChromosomeInfo> chrInfoSubList = new ArrayList<ChromosomeInfo>();
for (ChromosomeInfo chrInfo : chrInfoList) {
if (o.equals(chrInfo.getOrgName())) {
chrInfoSubList.add(chrInfo);
chrInfoMap.put(o, chrInfoSubList);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Constructor.
*
* @param im The intermine settings bundle
*/
public QueryToListService(InterMineAPI im) {
super(im);
bagManager = im.getBagManager();
}