litvinovg/vitro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'develop' of https://github.com/vivo-project/Vitro into develop

Browse source
This commit is contained in:
brianjlowe 2013-05-20 10:03:35 -04:00
commit 707d40e25c
29 changed files with 282 additions and 494 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
webapp/src/edu/cornell/mannlib/vedit/controller/BaseEditController.java
View file

@ -27,6 +27,7 @@ import edu.cornell.mannlib.vitro.webapp.controller.VitroHttpServlet;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
public class BaseEditController extends VitroHttpServlet {
@ -167,7 +168,7 @@ public class BaseEditController extends VitroHttpServlet {
}
if ( ontModel == null ) {
ontModel = (OntModel) ModelContext.getBaseOntModelSelector(ctx).getTBoxModel();
ontModel = ModelAccess.on(ctx).getOntModel(ModelID.BASE_TBOX);
}
return ontModel;

5
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/permissions/PermissionSetsLoader.java
View file

@ -32,10 +32,10 @@ import com.hp.hpl.jena.vocabulary.RDFS;
import edu.cornell.mannlib.vitro.webapp.beans.PermissionSet;
import edu.cornell.mannlib.vitro.webapp.beans.UserAccount;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.UserAccountsDao;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
/**
@ -100,8 +100,7 @@ public class PermissionSetsLoader implements ServletContextListener {
this.ctx = ctx;
this.ss = ss;
this.userAccountsModel = ModelContext.getBaseOntModelSelector(ctx)
.getUserAccountsModel();
this.userAccountsModel = ModelAccess.on(ctx).getUserAccountsModel();
this.permissionSetType = this.userAccountsModel
.getProperty(VitroVocabulary.PERMISSIONSET);

9
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/AbstractPageHandler.java
View file

@ -19,12 +19,12 @@ import com.hp.hpl.jena.ontology.OntModel;
import edu.cornell.mannlib.vitro.webapp.dao.DataPropertyStatementDao;
import edu.cornell.mannlib.vitro.webapp.dao.IndividualDao;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.ObjectPropertyStatementDao;
import edu.cornell.mannlib.vitro.webapp.dao.UserAccountsDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.i18n.I18n;
import edu.cornell.mannlib.vitro.webapp.i18n.I18nBundle;
@ -56,9 +56,8 @@ public abstract class AbstractPageHandler {
this.i18n = I18n.bundle(vreq);
this.ctx = vreq.getSession().getServletContext();
OntModelSelector oms = ModelContext.getUnionOntModelSelector(ctx);
userAccountsModel = oms.getUserAccountsModel();
unionModel = oms.getFullModel();
userAccountsModel = ModelAccess.on(ctx).getUserAccountsModel();
unionModel = ModelAccess.on(ctx).getOntModel(ModelID.UNION_FULL);
WebappDaoFactory wdf = (WebappDaoFactory) this.ctx
.getAttribute("webappDaoFactory");

38
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/VitroRequest.java
View file

@ -7,7 +7,6 @@ import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
@ -17,9 +16,7 @@ import com.hp.hpl.jena.query.Dataset;
import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.JenaBaseDao;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroModelSource.ModelName;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFService;
@ -107,14 +104,6 @@ public class VitroRequest extends HttpServletRequestWrapper {
setAttribute("dataset", dataset);
}
public void setJenaOntModel(OntModel ontModel) {
ModelAccess.on(this).setJenaOntModel(ontModel);
}
public void setOntModelSelector(OntModelSelector oms) {
setAttribute("ontModelSelector", oms);
}
/** gets assertions + inferences WebappDaoFactory with no filtering **/
public WebappDaoFactory getFullWebappDaoFactory() {
Object webappDaoFactoryAttr = _req.getAttribute("fullWebappDaoFactory");
@ -174,37 +163,28 @@ public class VitroRequest extends HttpServletRequestWrapper {
}
}
public OntModelSelector getOntModelSelector() {
return ModelAccess.on(this).getOntModelSelector();
}
public void setJenaOntModel(OntModel ontModel) {
ModelAccess.on(this).setJenaOntModel(ontModel);
}
public OntModel getJenaOntModel() {
return ModelAccess.on(this).getJenaOntModel();
}
public OntModelSelector getOntModelSelector() {
Object o = this.getAttribute("ontModelSelector");
if (o instanceof OntModelSelector) {
return (OntModelSelector) o;
} else {
return null;
}
}
public OntModel getAssertionsOntModel() {
return ModelAccess.on(getSession()).getBaseOntModel();
return ModelAccess.on(this).getBaseOntModel();
}
public OntModel getInferenceOntModel() {
OntModel jenaOntModel = (OntModel)_req.getSession().getAttribute( JenaBaseDao.INFERENCE_ONT_MODEL_ATTRIBUTE_NAME );
if ( jenaOntModel == null ) {
jenaOntModel = (OntModel)_req.getSession().getServletContext().getAttribute( JenaBaseDao.INFERENCE_ONT_MODEL_ATTRIBUTE_NAME );
}
return jenaOntModel;
return ModelAccess.on(this).getInferenceOntModel();
}
//Get the display and editing configuration model
public OntModel getDisplayModel(){
return ModelAccess.on(_req).getDisplayModel();
return ModelAccess.on(this).getDisplayModel();
}
/**

8
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/accounts/manageproxies/ajax/BasicProxiesGetter.java
View file

@ -6,7 +6,6 @@ import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletResponse;
@ -21,9 +20,8 @@ import com.hp.hpl.jena.query.QuerySolution;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.ajax.AbstractAjaxResponder;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.UrlBuilder;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.utils.SparqlQueryRunner;
import edu.cornell.mannlib.vitro.webapp.utils.SparqlQueryUtils;
import edu.cornell.mannlib.vitro.webapp.web.images.PlaceholderUtil;
@ -60,9 +58,7 @@ public class BasicProxiesGetter extends AbstractAjaxResponder {
super(servlet, vreq, resp);
term = getStringParameter(PARAMETER_SEARCH_TERM, "");
ServletContext ctx = vreq.getSession().getServletContext();
OntModelSelector oms = ModelContext.getUnionOntModelSelector(ctx);
userAccountsModel = oms.getUserAccountsModel();
userAccountsModel = ModelAccess.on(vreq).getUserAccountsModel();
placeholderImageUrl = UrlBuilder.getUrl(PlaceholderUtil
.getPlaceholderImagePathForType(vreq,

35
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/ajax/SparqlQueryAjaxController.java
View file

@ -2,11 +2,9 @@
package edu.cornell.mannlib.vitro.webapp.controller.ajax;
import static javax.servlet.http.HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
import java.io.IOException;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
@ -15,22 +13,14 @@ import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.query.Dataset;
import com.hp.hpl.jena.query.DatasetFactory;
import com.hp.hpl.jena.query.Query;
import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.query.QueryFactory;
import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.query.ResultSetFormatter;
import com.hp.hpl.jena.query.Syntax;
import com.hp.hpl.jena.rdf.model.Model;
import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.Actions;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.ajax.SparqlUtils.AjaxControllerException;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
/**
* Handle an AJAX request for a SPARQL query. On entry, the "query" parameter
@ -86,29 +76,12 @@ public class SparqlQueryAjaxController extends VitroAjaxController {
}
private Model locateModel(VitroRequest vreq, String modelParam)
throws AjaxControllerException {
Object o = getServletContext().getAttribute("baseOntModelSelector");
if (!(o instanceof OntModelSelector)) {
throw new AjaxControllerException(SC_INTERNAL_SERVER_ERROR,
"OntModelSelector not found");
}
OntModelSelector oms = (OntModelSelector) o;
Model model = null;
private Model locateModel(VitroRequest vreq, String modelParam) {
if (OPTION_MODEL_USER_ACCOUNTS.equals(modelParam)) {
model = oms.getUserAccountsModel();
return ModelAccess.on(vreq).getUserAccountsModel();
} else {
// TODO What is the appropriate way to do this?
// model = oms.getFullModel();
model = vreq.getJenaOntModel();
return ModelAccess.on(vreq).getJenaOntModel();
}
if (model == null) {
throw new AjaxControllerException(SC_INTERNAL_SERVER_ERROR,
"Model '' not found.");
}
return model;
}
private String locateQueryParam(VitroRequest vreq)

9
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/edit/RefactorOperationController.java
View file

@ -49,7 +49,7 @@ import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.event.EditEvent;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.FileGraphSetup;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase;
@ -235,10 +235,10 @@ public class RefactorOperationController extends BaseEditController {
Model model = null;
if (JenaDataSourceSetupBase.JENA_TBOX_ASSERTIONS_MODEL.equals(graphURI)) {
model = ModelContext.getBaseOntModelSelector(getServletContext()).getTBoxModel();
model = ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_TBOX);
doNotify = true;
} else if (JenaDataSourceSetupBase.JENA_DB_MODEL.equals(graphURI)) {
model = ModelContext.getBaseOntModelSelector(getServletContext()).getABoxModel();
model = ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_ABOX);
doNotify = true;
} else {
model = dataset.getNamedModel(graphURI);
@ -251,8 +251,7 @@ public class RefactorOperationController extends BaseEditController {
dataset.getLock().leaveCriticalSection();
}
renameResourceInModel(ModelContext.getOntModelSelector(
getServletContext()).getUserAccountsModel(),
renameResourceInModel(ModelAccess.on(getServletContext()).getUserAccountsModel(),
userURI, oldURIStr, newURIStr, !NOTIFY);
// there are no statements to delete, but we want indexes updated appropriately

2
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaAdminActions.java
View file

@ -309,7 +309,7 @@ public class JenaAdminActions extends BaseEditController {
memoryModel = ModelAccess.on(getServletContext()).getBaseOntModel();
System.out.println("baseOntModel");
} else if (request.getParameter("inferences") != null) {
memoryModel = (OntModel) getServletContext().getAttribute("inferenceOntModel");
memoryModel = ModelAccess.on(getServletContext()).getInferenceOntModel();
System.out.println("inferenceOntModel");
} else if (request.getParameter("pellet") != null) {
memoryModel = (OntModel) getServletContext().getAttribute("pelletOntModel");

29
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaExportController.java
View file

@ -5,8 +5,6 @@ package edu.cornell.mannlib.vitro.webapp.controller.jena;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.HashMap;
import java.util.Map;
@ -30,8 +28,9 @@ import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.Actions;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.JenaModelUtils;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceModelMaker;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFService;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
@ -121,8 +120,7 @@ public class JenaExportController extends BaseEditController {
if( "abox".equals(subgraphParam)){
model = ModelFactory.createDefaultModel();
if("inferred".equals(assertedOrInferredParam)){
model = ModelContext.getInferenceOntModelSelector(
getServletContext()).getABoxModel();
model = ModelAccess.on(getServletContext()).getOntModel(ModelID.INFERRED_ABOX);
}
else if("full".equals(assertedOrInferredParam)){
outputSparqlConstruct(ABOX_FULL_CONSTRUCT, formatParam, response);
@ -137,10 +135,9 @@ public class JenaExportController extends BaseEditController {
// so we'll extract the whole ontology and then include
// only those statements that are in the inferred graph
Model tempModel = xutil.extractTBox(
ModelContext.getUnionOntModelSelector(
getServletContext()).getTBoxModel(), ontologyURI);
Model inferenceModel = ModelContext.getInferenceOntModelSelector(
getServletContext()).getTBoxModel();
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX),
ontologyURI);
Model inferenceModel = ModelAccess.on(getServletContext()).getOntModel(ModelID.INFERRED_TBOX);
inferenceModel.enterCriticalSection(Lock.READ);
try {
model = tempModel.intersection(inferenceModel);
@ -149,12 +146,11 @@ public class JenaExportController extends BaseEditController {
}
} else if ("full".equals(assertedOrInferredParam)) {
model = xutil.extractTBox(
ModelContext.getUnionOntModelSelector(
getServletContext()).getTBoxModel(), ontologyURI);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX),
ontologyURI);
} else {
model = xutil.extractTBox(
ModelContext.getBaseOntModelSelector(
getServletContext()).getTBoxModel(), ontologyURI);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_TBOX), ontologyURI);
}
}
@ -162,10 +158,8 @@ public class JenaExportController extends BaseEditController {
if("inferred".equals(assertedOrInferredParam)){
ontModel = xutil.extractTBox(
dataset, ontologyURI, INFERENCE_GRAPH);
ontModel.addSubModel(ModelContext.getInferenceOntModelSelector(
getServletContext()).getABoxModel());
ontModel.addSubModel(ModelContext.getInferenceOntModelSelector(
getServletContext()).getTBoxModel());
ontModel.addSubModel(ModelAccess.on(getServletContext()).getOntModel(ModelID.INFERRED_ABOX));
ontModel.addSubModel(ModelAccess.on(getServletContext()).getOntModel(ModelID.INFERRED_TBOX));
}
else if("full".equals(assertedOrInferredParam)){
outputSparqlConstruct(FULL_FULL_CONSTRUCT, formatParam, response);
@ -283,7 +277,6 @@ public class JenaExportController extends BaseEditController {
}
}
static final String INFERENCES_ONT_MODEL_ATTR = "inferenceOntModel";
static final String FULL_GRAPH = "?g";
static final String ASSERTIONS_GRAPH = "<http://vitro.mannlib.cornell.edu/default/vitro-kb-2>";
static final String INFERENCE_GRAPH = "<http://vitro.mannlib.cornell.edu/default/vitro-kb-inf>";

30
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaIngestController.java
View file

@ -68,8 +68,8 @@ import edu.cornell.mannlib.vitro.webapp.beans.Ontology;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.OntologyDao;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceGraph;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceModelMaker;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroJenaModelMaker;
@ -80,8 +80,8 @@ import edu.cornell.mannlib.vitro.webapp.rdfservice.ChangeSet;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFService;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.ContentModelSetup;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase;
import edu.cornell.mannlib.vitro.webapp.utils.SparqlQueryUtils;
import edu.cornell.mannlib.vitro.webapp.utils.jena.JenaIngestUtils;
import edu.cornell.mannlib.vitro.webapp.utils.jena.JenaIngestUtils.MergeResult;
@ -662,8 +662,7 @@ public class JenaIngestController extends BaseEditController {
* get baseOnt and infOnt models
*/
OntModel baseOntModel = ModelAccess.on(getServletContext()).getBaseOntModel();
OntModel tboxOntModel = ModelContext.getUnionOntModelSelector(
getServletContext()).getTBoxModel();
OntModel tboxOntModel = ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX);
/*
* calling method that does the merge operation.
@ -826,10 +825,10 @@ public class JenaIngestController extends BaseEditController {
return;
}
Model m = modelMaker.getModel(modelName);
ModelContext.getBaseOntModelSelector(getServletContext()).getTBoxModel().addSubModel(m);
ModelContext.getBaseOntModelSelector(getServletContext()).getABoxModel().addSubModel(m);
ModelContext.getUnionOntModelSelector(getServletContext()).getABoxModel().addSubModel(m);
ModelContext.getUnionOntModelSelector(getServletContext()).getTBoxModel().addSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_ABOX).addSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_TBOX).addSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_ABOX).addSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX).addSubModel(m);
attachedModels.put(modelName, m);
log.info("Attached " + modelName + " (" + m.hashCode() + ") to webapp");
}
@ -839,10 +838,10 @@ public class JenaIngestController extends BaseEditController {
if (m == null) {
return;
}
ModelContext.getBaseOntModelSelector(getServletContext()).getTBoxModel().removeSubModel(m);
ModelContext.getBaseOntModelSelector(getServletContext()).getABoxModel().removeSubModel(m);
ModelContext.getUnionOntModelSelector(getServletContext()).getABoxModel().removeSubModel(m);
ModelContext.getUnionOntModelSelector(getServletContext()).getTBoxModel().removeSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_ABOX).removeSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_TBOX).removeSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_ABOX).removeSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX).removeSubModel(m);
attachedModels.remove(modelName);
log.info("Detached " + modelName + " (" + m.hashCode() + ") from webapp");
}
@ -1315,12 +1314,7 @@ public class JenaIngestController extends BaseEditController {
} else if ("vitro:baseOntModel".equals(name)) {
return ModelAccess.on(request.getSession()).getBaseOntModel();
} else if ("vitro:inferenceOntModel".equals(name)) {
Object sessionOntModel = request.getSession().getAttribute("inferenceOntModel");
if (sessionOntModel != null && sessionOntModel instanceof OntModel) {
return (OntModel) sessionOntModel;
} else {
return (OntModel) context.getAttribute("inferenceOntModel");
}
return ModelAccess.on(request.getSession()).getInferenceOntModel();
} else {
return getVitroJenaModelMaker(request,context).getModel(name);
}

21
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/RDFUploadController.java
View file

@ -34,7 +34,9 @@ import edu.cornell.mannlib.vedit.beans.LoginStatusBean;
import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.JenaModelUtils;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
@ -170,14 +172,12 @@ public class RDFUploadController extends JenaIngestController {
JenaModelUtils xutil = new JenaModelUtils();
OntModel tboxModel = getTBoxModel(
request.getSession(), getServletContext());
OntModel tboxModel = getTBoxModel(request.getSession());
OntModel aboxModel = getABoxModel(
request.getSession(), getServletContext());
OntModel tboxChangeModel = null;
Model aboxChangeModel = null;
OntModelSelector ontModelSelector = ModelContext.getOntModelSelector(
getServletContext());
OntModelSelector ontModelSelector = ModelAccess.on(getServletContext()).getOntModelSelector();
if (tboxModel != null) {
boolean AGGRESSIVE = true;
@ -428,17 +428,8 @@ public class RDFUploadController extends JenaIngestController {
return ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, abox);
}
private OntModel getTBoxModel(HttpSession session, ServletContext ctx) {
if (session != null
&& session.getAttribute("baseOntModelSelector")
instanceof OntModelSelector) {
return ((OntModelSelector)
session.getAttribute("baseOntModelSelector"))
.getTBoxModel();
} else {
return ((OntModelSelector)
ctx.getAttribute("baseOntModelSelector")).getTBoxModel();
}
private OntModel getTBoxModel(HttpSession session) {
return ModelAccess.on(session).getOntModel(ModelID.BASE_TBOX);
}
private static final Log log = LogFactory.getLog(

4
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/DisplayVocabulary.java
View file

@ -115,10 +115,6 @@ public class DisplayVocabulary {
public static final String USE_TBOX_MODEL_PARAM = "useThisTboxModel";
public static final String USE_DISPLAY_MODEL_PARAM = "useThisDisplayModel";
//Attribute values used to store display tbox/display display model in servlet context
public static final String CONTEXT_DISPLAY_TBOX = "displayOntModelTBOX";
public static final String CONTEXT_DISPLAY_DISPLAY = "displayOntModelDisplayModel";
//URL for menu management
public static final String PROCESS_MENU_MANAGEMENT_URL = "/menuManagementEdit";
public static final String REORDER_MENU_URL = PROCESS_MENU_MANAGEMENT_URL + "?cmd=Reorder&" + SWITCH_TO_DISPLAY_MODEL + "=true";

326
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/ModelAccess.java
View file

@ -9,12 +9,55 @@ import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.ontology.OntModel;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
/**
* Hierarchical storage for models. TODO
*
* Could this be extended? Could it be used to replace or implement these
* methods?
*
* <pre>
* VitroRequest.getAssertionsWebappDaoFactory()
* VitroRequest.getDeductionsWebappDaoFactory()
* VitroRequest.getFullWebappDaoFactory()
* VitroRequest.getRDFService()
* VitroRequest.getUnfilteredRDFService()
* VitroRequest.getWebappDaoFactory()
* VitroRequest.getWriteModel()
* VitroRequest.getJenaOntModel()
* VitroRequest.setJenaOntModel()
* OntModelSelector.getAboxModel
* OntModelSelector.getApplicationMetadataModel()
* OntModelSelector.getFullModel()
* OntModelSelector.getTBoxModel()
* OntModelSelector.getTBoxModel(ontologyURI)
* OntModelSelector.getUserAccountsModel()
* VitroModelSource.getModel(URL)
* VitroModelSource.getModel(URL, loadIfAbsent)
* VitroModelSource.openModel(name)
* VitroModelSource.openModelIfPresent(string)
* ServletContext.getAttribute("assertionsWebappDaoFactory")
* ServletContext.getAttribute("baseOntModelSelector")
* ServletContext.getAttribute("jenaPersistentOntModel")
* ServletContext.getAttribute("pelletOntModel")
* ServletContext.getAttribute("webappDaoFactory")
* VitroJenaModelMaker
* VitroJenaSpecialModelMaker
* JenaDataSourceSetupBase.getApplicationDataSource(ctx)
* JenaDataSourceSetupBase.getStartupDataset()
* HttpSession.getAttribute("jenaAuditModel")
* </pre>
*/
public class ModelAccess {
private static final Log log = LogFactory.getLog(ModelAccess.class);
/** These attributes should only be accessed through this class. */
private static final String ATTRIBUTE_NAME = ModelAccess.class.getName();
@ -32,6 +75,10 @@ public class ModelAccess {
UNION_ABOX, UNION_TBOX, UNION_FULL
}
private enum Scope {
CONTEXT, SESSION, REQUEST
}
// ----------------------------------------------------------------------
// Factory methods
// ----------------------------------------------------------------------
@ -42,7 +89,7 @@ public class ModelAccess {
return (ModelAccess) o;
} else {
ModelAccess parent = on(req.getSession());
ModelAccess ma = new ModelAccess(parent);
ModelAccess ma = new ModelAccess(Scope.REQUEST, parent);
req.setAttribute(ATTRIBUTE_NAME, ma);
return ma;
}
@ -54,7 +101,7 @@ public class ModelAccess {
return (ModelAccess) o;
} else {
ModelAccess parent = on(session.getServletContext());
ModelAccess ma = new ModelAccess(parent);
ModelAccess ma = new ModelAccess(Scope.SESSION, parent);
session.setAttribute(ATTRIBUTE_NAME, ma);
return ma;
}
@ -65,31 +112,41 @@ public class ModelAccess {
if (o instanceof ModelAccess) {
return (ModelAccess) o;
} else {
ModelAccess ma = new ModelAccess(null);
ModelAccess ma = new ModelAccess(Scope.CONTEXT, null);
ctx.setAttribute(ATTRIBUTE_NAME, ma);
return ma;
}
}
// ----------------------------------------------------------------------
// Instance methods
// The instance
// ----------------------------------------------------------------------
private final Scope scope;
private final ModelAccess parent;
private final Map<String, OntModel> modelMap = new HashMap<>();
public ModelAccess(ModelAccess parent) {
public ModelAccess(Scope scope, ModelAccess parent) {
this.scope = scope;
this.parent = parent;
}
// ----------------------------------------------------------------------
// Accessing the models
// ----------------------------------------------------------------------
public OntModel getApplicationMetadataModel() {
return getOntModel(ModelID.APPLICATION_METADATA);
}
public void setUserAccountsModel(OntModel m) {
setOntModel(ModelID.USER_ACCOUNTS, m);
}
public OntModel getUserAccountsModel() {
return getOntModel(ModelID.USER_ACCOUNTS);
}
public void setDisplayModel(OntModel m) {
setOntModel(ModelID.DISPLAY, m);
}
@ -101,7 +158,7 @@ public class ModelAccess {
public void setJenaOntModel(OntModel m) {
setOntModel(ModelID.UNION_FULL, m);
}
public OntModel getJenaOntModel() {
return getOntModel(ModelID.UNION_FULL);
}
@ -109,174 +166,14 @@ public class ModelAccess {
public void setBaseOntModel(OntModel m) {
setOntModel(ModelID.BASE_FULL, m);
}
public OntModel getBaseOntModel() {
return getOntModel(ModelID.BASE_FULL);
}
// public OntModel getDisplayTboxOntModel() {
// throw new RuntimeException(
// "ModelAccess.getDisplayTboxOntModel not implemented.");
// }
//
// public OntModel getDisplayModelDisplayOntModel() {
// throw new RuntimeException(
// "ModelAccess.getDisplayModelDisplayOntModel not implemented.");
// }
//
// public OntModelSelector getOntModelSelector() {
// return getUnionOntModelSelector();
// }
//
// public OntModelSelector getBaseOntModelSelector() {
// return new FacadeOntModelSelector(this, ModelID.BASE_ABOX,
// ModelID.BASE_TBOX, ModelID.BASE_FULL);
// }
//
// public OntModelSelector getInferenceOntModelSelector() {
// return new FacadeOntModelSelector(this, ModelID.INFERRED_ABOX,
// ModelID.INFERRED_TBOX, ModelID.INFERRED_FULL);
// }
//
// public OntModelSelector getUnionOntModelSelector() {
// return new FacadeOntModelSelector(this, ModelID.UNION_ABOX,
// ModelID.UNION_TBOX, ModelID.UNION_FULL);
// }
//
// private static class FacadeOntModelSelector implements OntModelSelector {
// private final ModelAccess parent;
// private final ModelID aboxID;
// private final ModelID tboxID;
// private final ModelID fullID;
//
// public FacadeOntModelSelector(ModelAccess parent, ModelID aboxID,
// ModelID tboxID, ModelID fullID) {
// this.parent = parent;
// this.aboxID = aboxID;
// this.tboxID = tboxID;
// this.fullID = fullID;
// }
//
// @Override
// public OntModel getABoxModel() {
// return parent.getOntModel(aboxID);
// }
//
// @Override
// public OntModel getTBoxModel() {
// return parent.getOntModel(tboxID);
// }
//
// @Override
// public OntModel getTBoxModel(String ontologyURI) {
// return parent.getOntModel(tboxID);
// }
//
// @Override
// public OntModel getFullModel() {
// return parent.getOntModel(fullID);
// }
//
// @Override
// public OntModel getApplicationMetadataModel() {
// return parent.getOntModel(ModelID.APPLICATION_METADATA);
// }
//
// @Override
// public OntModel getUserAccountsModel() {
// return parent.getOntModel(ModelID.USER_ACCOUNTS);
// }
//
// @Override
// public OntModel getDisplayModel() {
// return parent.getOntModel(ModelID.DISPLAY);
// }
// }
/**
* <pre>
* From ModelContext
*
* public static OntModelSelector getOntModelSelector(ServletContext ctx) {
* return (OntModelSelector) ctx.getAttribute(ONT_MODEL_SELECTOR);
* }
*
* public static void setOntModelSelector(OntModelSelector oms, ServletContext ctx) {
* ctx.setAttribute(ONT_MODEL_SELECTOR, oms);
* }
*
* public static OntModelSelector getUnionOntModelSelector(ServletContext ctx) {
* return (OntModelSelector) ctx.getAttribute(UNION_ONT_MODEL_SELECTOR);
* }
*
* public static void setUnionOntModelSelector(OntModelSelector oms, ServletContext ctx) {
* ctx.setAttribute(UNION_ONT_MODEL_SELECTOR, oms);
* }
*
* public static OntModelSelector getBaseOntModelSelector(ServletContext ctx) {
* return (OntModelSelector) ctx.getAttribute(BASE_ONT_MODEL_SELECTOR);
* }
*
* public static void setBaseOntModelSelector(OntModelSelector oms, ServletContext ctx) {
* ctx.setAttribute(BASE_ONT_MODEL_SELECTOR, oms);
* }
*
* public static OntModelSelector getInferenceOntModelSelector(ServletContext ctx) {
* return (OntModelSelector) ctx.getAttribute(INFERENCE_ONT_MODEL_SELECTOR);
* }
*
* public static void setInferenceOntModelSelector(OntModelSelector oms, ServletContext ctx) {
* ctx.setAttribute(INFERENCE_ONT_MODEL_SELECTOR, oms);
* }
*
* public static OntModel getInferenceOntModel(ServletContext ctx) {
* return (OntModel) ctx.getAttribute(INFERENCE_ONT_MODEL);
* }
*
* public static void setInferenceOntModel(OntModel ontModel, ServletContext ctx) {
* ctx.setAttribute(INFERENCE_ONT_MODEL, ontModel);
* }
*
* </pre>
*/
/**
* <pre>
* VitroRequest.getAssertionsWebappDaoFactory()
* VitroRequest.getDeductionsWebappDaoFactory()
* VitroRequest.getFullWebappDaoFactory()
* VitroRequest.getRDFService()
* VitroRequest.getUnfilteredRDFService()
* VitroRequest.getWebappDaoFactory()
* VitroRequest.getWriteModel()
* VitroRequest.getJenaOntModel()
* VitroRequest.setJenaOntModel()
* ModelContext.getBaseOntModelSelector()
* ModelContext.getInferenceOntModel()
* ModelContext.getInferenceOntModelSelector()
* ModelContext.getOntModelSelector()
* ModelContext.getUnionOntModelSelector()
* OntModelSelector.getAboxModel
* OntModelSelector.getApplicationMetadataModel()
* OntModelSelector.getFullModel()
* OntModelSelector.getTBoxModel()
* OntModelSelector.getTBoxModel(ontologyURI)
* OntModelSelector.getUserAccountsModel()
* VitroModelSource.getModel(URL)
* VitroModelSource.getModel(URL, loadIfAbsent)
* VitroModelSource.openModel(name)
* VitroModelSource.openModelIfPresent(string)
* ServletContext.getAttribute("assertionsWebappDaoFactory")
* ServletContext.getAttribute("baseOntModelSelector")
* ServletContext.getAttribute("jenaPersistentOntModel")
* ServletContext.getAttribute("pelletOntModel")
* ServletContext.getAttribute("webappDaoFactory")
* VitroJenaModelMaker
* VitroJenaSpecialModelMaker
* JenaDataSourceSetupBase.getApplicationDataSource(ctx)
* JenaDataSourceSetupBase.getStartupDataset()
* HttpSession.getAttribute("jenaAuditModel")
* </pre>
*/
public OntModel getInferenceOntModel() {
return getOntModel(ModelID.INFERRED_FULL);
}
public void setOntModel(ModelID id, OntModel ontModel) {
String key = id.toString();
@ -290,12 +187,97 @@ public class ModelAccess {
public OntModel getOntModel(ModelID id) {
String key = id.toString();
if (modelMap.containsKey(key)) {
log.debug("Using " + id + " model from " + scope);
return modelMap.get(key);
} else if (parent != null) {
return parent.getOntModel(id);
} else {
log.warn("No model found for " + id);
return null;
}
}
// ----------------------------------------------------------------------
// Accessing the OntModelSelectors
// ----------------------------------------------------------------------
public OntModelSelector getOntModelSelector() {
return getUnionOntModelSelector();
}
public OntModelSelector getBaseOntModelSelector() {
return new FacadeOntModelSelector(this, ModelID.BASE_ABOX,
ModelID.BASE_TBOX, ModelID.BASE_FULL);
}
public OntModelSelector getInferenceOntModelSelector() {
return new FacadeOntModelSelector(this, ModelID.INFERRED_ABOX,
ModelID.INFERRED_TBOX, ModelID.INFERRED_FULL);
}
public OntModelSelector getUnionOntModelSelector() {
return new FacadeOntModelSelector(this, ModelID.UNION_ABOX,
ModelID.UNION_TBOX, ModelID.UNION_FULL);
}
// ----------------------------------------------------------------------
// Helper classes
// ----------------------------------------------------------------------
/**
* This OntModelSelector doesn't actually hold any OntModels. Instead, it
* links back to the ModelAccess that it was created from. So, if you change
* a model on the ModelAccess, it will change on the OntModelSelector also.
* Even if the OntModelSelector was created first.
*/
private static class FacadeOntModelSelector implements OntModelSelector {
private final ModelAccess parent;
private final ModelID aboxID;
private final ModelID tboxID;
private final ModelID fullID;
public FacadeOntModelSelector(ModelAccess parent, ModelID aboxID,
ModelID tboxID, ModelID fullID) {
this.parent = parent;
this.aboxID = aboxID;
this.tboxID = tboxID;
this.fullID = fullID;
}
@Override
public OntModel getABoxModel() {
return parent.getOntModel(aboxID);
}
@Override
public OntModel getTBoxModel() {
return parent.getOntModel(tboxID);
}
@Override
public OntModel getTBoxModel(String ontologyURI) {
return parent.getOntModel(tboxID);
}
@Override
public OntModel getFullModel() {
return parent.getOntModel(fullID);
}
@Override
public OntModel getApplicationMetadataModel() {
return parent.getOntModel(ModelID.APPLICATION_METADATA);
}
@Override
public OntModel getUserAccountsModel() {
return parent.getOntModel(ModelID.USER_ACCOUNTS);
}
@Override
public OntModel getDisplayModel() {
return parent.getOntModel(ModelID.DISPLAY);
}
}
}

2
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/JenaBaseDao.java
View file

@ -54,8 +54,6 @@ public class JenaBaseDao extends JenaBaseDaoCon {
public static final boolean KEEP_ONLY_IF_TRUE = true; //used for updatePropertyBooleanValue()
public static final boolean KEEP_ONLY_IF_FALSE = false; //used for updatePropertyBooleanValue()
public static final String INFERENCE_ONT_MODEL_ATTRIBUTE_NAME = "inferenceOntModel";
protected static final Log log = LogFactory.getLog(JenaBaseDao.class.getName());
/* ******************* static constants ****************** */

51
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/ModelContext.java
View file

@ -7,65 +7,14 @@ import javax.servlet.ServletContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.rdf.model.ModelChangedListener;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils;
public class ModelContext {
private static final Log log = LogFactory.getLog(ModelContext.class);
private static final String ONT_MODEL_SELECTOR = "ontModelSelector";
private static final String UNION_ONT_MODEL_SELECTOR = "unionOntModelSelector";
private static final String BASE_ONT_MODEL_SELECTOR = "baseOntModelSelector";
private static final String INFERENCE_ONT_MODEL_SELECTOR = "inferenceOntModelSelector";
private static final String INFERENCE_ONT_MODEL = "inferenceOntModel";
public ModelContext() {}
public static OntModelSelector getOntModelSelector(ServletContext ctx) {
return (OntModelSelector) ctx.getAttribute(ONT_MODEL_SELECTOR);
}
public static void setOntModelSelector(OntModelSelector oms, ServletContext ctx) {
ctx.setAttribute(ONT_MODEL_SELECTOR, oms);
}
public static OntModelSelector getUnionOntModelSelector(ServletContext ctx) {
return (OntModelSelector) ctx.getAttribute(UNION_ONT_MODEL_SELECTOR);
}
public static void setUnionOntModelSelector(OntModelSelector oms, ServletContext ctx) {
ctx.setAttribute(UNION_ONT_MODEL_SELECTOR, oms);
}
public static OntModelSelector getBaseOntModelSelector(ServletContext ctx) {
return (OntModelSelector) ctx.getAttribute(BASE_ONT_MODEL_SELECTOR);
}
public static void setBaseOntModelSelector(OntModelSelector oms, ServletContext ctx) {
ctx.setAttribute(BASE_ONT_MODEL_SELECTOR, oms);
}
public static OntModelSelector getInferenceOntModelSelector(ServletContext ctx) {
return (OntModelSelector) ctx.getAttribute(INFERENCE_ONT_MODEL_SELECTOR);
}
public static void setInferenceOntModelSelector(OntModelSelector oms, ServletContext ctx) {
ctx.setAttribute(INFERENCE_ONT_MODEL_SELECTOR, oms);
}
public static OntModel getInferenceOntModel(ServletContext ctx) {
return (OntModel) ctx.getAttribute(INFERENCE_ONT_MODEL);
}
public static void setInferenceOntModel(OntModel ontModel, ServletContext ctx) {
ctx.setAttribute(INFERENCE_ONT_MODEL, ontModel);
}
/**
* Register a listener to the models needed to get changes to:
* Basic abox statemetns:

7
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/VitroJenaModelMaker.java
View file

@ -316,12 +316,7 @@ public class VitroJenaModelMaker implements ModelMaker {
} else if ("vitro:baseOntModel".equals(modelName)) {
return ModelAccess.on(request.getSession()).getBaseOntModel();
} else if ("vitro:inferenceOntModel".equals(modelName)) {
Object sessionOntModel = request.getSession().getAttribute("inferenceOntModel");
if (sessionOntModel != null && sessionOntModel instanceof OntModel) {
return (OntModel) sessionOntModel;
} else {
return (OntModel) request.getSession().getServletContext().getAttribute("inferenceOntModel");
}
return ModelAccess.on(request.getSession()).getInferenceOntModel();
} else {
return null;
}

8
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/VitroJenaSpecialModelMaker.java
View file

@ -8,7 +8,6 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.graph.GraphMaker;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelMaker;
import com.hp.hpl.jena.rdf.model.ModelReader;
@ -121,12 +120,7 @@ public class VitroJenaSpecialModelMaker implements ModelMaker {
} else if ("vitro:baseOntModel".equals(modelName)) {
return ModelAccess.on(request.getSession()).getBaseOntModel();
} else if ("vitro:inferenceOntModel".equals(modelName)) {
Object sessionOntModel = request.getSession().getAttribute("inferenceOntModel");
if (sessionOntModel != null && sessionOntModel instanceof OntModel) {
return (OntModel) sessionOntModel;
} else {
return (OntModel) request.getSession().getServletContext().getAttribute("inferenceOntModel");
}
return ModelAccess.on(request.getSession()).getInferenceOntModel();
} else {
return null;
}

6
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/VitroModelSource.java
View file

@ -9,8 +9,8 @@ import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelReader;
import com.hp.hpl.jena.rdf.model.ModelSource;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
/**
* ModelSource that will handle specially named Vitro models such
@ -113,9 +113,9 @@ public class VitroModelSource implements ModelSource {
case DISPLAY:
return ModelAccess.on(context).getDisplayModel();
case DISPLAY_TBOX:
return (Model) context.getAttribute(DisplayVocabulary.CONTEXT_DISPLAY_TBOX);
return ModelAccess.on(context).getOntModel(ModelID.DISPLAY_TBOX);
case DISPLAY_DISPLAY:
return (Model) context.getAttribute(DisplayVocabulary.CONTEXT_DISPLAY_DISPLAY);
return ModelAccess.on(context).getOntModel(ModelID.DISPLAY_DISPLAY);
case USER_ACCOUNTS:
throw new IllegalArgumentException("getNamedModel() Does not yet handle USER_ACCOUNTS");
default:

26
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/StandardModelSelector.java
View file

@ -10,35 +10,15 @@ import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.ontology.OntModel;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
public class StandardModelSelector implements ModelSelector {
private static final Log log = LogFactory.getLog(StandardModelSelector.class);
public OntModel getModel(HttpServletRequest request, ServletContext context) {
VitroRequest vreq = new VitroRequest( request );
Object sessionOntModel = null;
if( vreq.getSession() != null) {
OntModelSelector oms = (OntModelSelector) vreq.getSession()
.getAttribute("unionOntModelSelector");
if (oms != null) {
sessionOntModel = oms.getABoxModel();
}
}
if(sessionOntModel != null && sessionOntModel instanceof OntModel ) {
log.debug("using OntModelSelector from session");
return (OntModel)sessionOntModel;
} else if (vreq.getOntModelSelector() != null) {
log.debug("using OntModelSelector from request");
return vreq.getOntModelSelector().getABoxModel();
} else {
log.debug("using OntModelSelector from context");
return ((OntModelSelector) context
.getAttribute("unionOntModelSelector")).getABoxModel();
}
return ModelAccess.on(request.getSession()).getOntModel(ModelID.UNION_ABOX);
}
public static final ModelSelector selector = new StandardModelSelector();

7
webapp/src/edu/cornell/mannlib/vitro/webapp/filters/VitroRequestPrep.java
View file

@ -3,7 +3,6 @@
package edu.cornell.mannlib.vitro.webapp.filters;
import static edu.cornell.mannlib.vitro.webapp.controller.VitroRequest.SPECIAL_WRITE_MODEL;
import static edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary.CONTEXT_DISPLAY_TBOX;
import static edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary.SWITCH_TO_DISPLAY_MODEL;
import static edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary.USE_DISPLAY_MODEL_PARAM;
import static edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary.USE_MODEL_PARAM;
@ -47,7 +46,6 @@ import edu.cornell.mannlib.vitro.webapp.dao.filtering.WebappDaoFactoryFiltering;
import edu.cornell.mannlib.vitro.webapp.dao.filtering.filters.FilterFactory;
import edu.cornell.mannlib.vitro.webapp.dao.filtering.filters.HideFromDisplayByPolicyFilter;
import edu.cornell.mannlib.vitro.webapp.dao.filtering.filters.VitroFilters;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroModelSource;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactorySDB;
@ -176,8 +174,7 @@ public class VitroRequestPrep implements Filter {
if (vreq.getUnfilteredWebappDaoFactory() == null) {
vreq.setUnfilteredWebappDaoFactory(new WebappDaoFactorySDB(
RDFServiceUtils.getRDFServiceFactory(ctx).getRDFService(),
ModelContext.getUnionOntModelSelector(
ctx)));
ModelAccess.on(ctx).getUnionOntModelSelector()));
}
req.setAttribute("VitroRequestPrep.setup", new Integer(1));
@ -236,7 +233,7 @@ public class VitroRequestPrep implements Filter {
// If they asked for the display model, give it to them.
if (isParameterPresent(vreq, SWITCH_TO_DISPLAY_MODEL)) {
OntModel mainOntModel = ModelAccess.on(_context).getDisplayModel();
OntModel tboxOntModel = (OntModel) _context.getAttribute(CONTEXT_DISPLAY_TBOX);
OntModel tboxOntModel = ModelAccess.on(_context).getOntModel(ModelID.DISPLAY_TBOX);
setSpecialWriteModel(vreq, mainOntModel);
vreq.setAttribute(VitroRequest.ID_FOR_ABOX_MODEL, VitroModelSource.ModelName.DISPLAY.toString());

24
webapp/src/edu/cornell/mannlib/vitro/webapp/filters/WebappDaoFactorySDBPrep.java
View file

@ -26,6 +26,7 @@ import com.hp.hpl.jena.rdf.model.ModelFactory;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactoryConfig;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
@ -82,8 +83,6 @@ public class WebappDaoFactorySDBPrep implements Filter {
}
}
OntModelSelector oms = ModelContext.getUnionOntModelSelector(_ctx);
OntModelSelector baseOms = ModelContext.getBaseOntModelSelector(_ctx);
String defaultNamespace = (String) _ctx.getAttribute("defaultNamespace");
WebappDaoFactory wadf = null;
VitroRequest vreq = new VitroRequest((HttpServletRequest) request);
@ -104,29 +103,34 @@ public class WebappDaoFactorySDBPrep implements Filter {
if (Boolean.valueOf(ConfigurationProperties.getBean(vreq).getProperty(
"RDFService.languageFilter", "true"))) {
rdfService = new LanguageFilteringRDFService(unfilteredRDFService, langs);
oms = LanguageFilteringUtils.replaceDisplayModelInSelector(oms,
LanguageFilteringUtils.wrapOntModelInALanguageFilter(oms.getDisplayModel(), request));
baseOms = LanguageFilteringUtils.replaceDisplayModelInSelector(baseOms, oms.getDisplayModel());
OntModel rawDisplayModel = ModelAccess.on(vreq.getSession()).getDisplayModel();
OntModel filteredDisplayModel = LanguageFilteringUtils.wrapOntModelInALanguageFilter(rawDisplayModel, request);
ModelAccess.on(vreq).setDisplayModel(filteredDisplayModel);
} else {
rdfService = unfilteredRDFService;
}
Dataset dataset = new RDFServiceDataset(rdfService);
OntModelSelector oms = ModelAccess.on(_ctx).getUnionOntModelSelector();
wadf = new WebappDaoFactorySDB(rdfService, oms, config);
WebappDaoFactory assertions = new WebappDaoFactorySDB(
OntModelSelector baseOms = ModelAccess.on(_ctx).getBaseOntModelSelector();
WebappDaoFactory assertions = new WebappDaoFactorySDB(
rdfService, baseOms, config, SDBDatasetMode.ASSERTIONS_ONLY);
vreq.setRDFService(rdfService);
vreq.setUnfilteredRDFService(unfilteredRDFService);
vreq.setWebappDaoFactory(wadf);
vreq.setAssertionsWebappDaoFactory(assertions);
vreq.setFullWebappDaoFactory(wadf);
vreq.setUnfilteredWebappDaoFactory(new WebappDaoFactorySDB(
rdfService, ModelContext.getUnionOntModelSelector(_ctx)));
rdfService, ModelAccess.on(_ctx).getUnionOntModelSelector()));
vreq.setDataset(dataset);
vreq.setOntModelSelector(baseOms);
vreq.setJenaOntModel(ModelFactory.createOntologyModel(
OntModelSpec.OWL_MEM, dataset.getDefaultModel()));
ModelAccess.on(vreq).setJenaOntModel(
ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, dataset.getDefaultModel()));
request.setAttribute("WebappDaoFactorySDBPrep.setup", 1);

16
webapp/src/edu/cornell/mannlib/vitro/webapp/filters/WebappDaoFactorySparqlPrep.java
View file

@ -27,7 +27,6 @@ import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.graph.Graph;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntModelSpec;
import com.hp.hpl.jena.query.DataSource;
import com.hp.hpl.jena.query.Dataset;
import com.hp.hpl.jena.query.DatasetFactory;
import com.hp.hpl.jena.rdf.model.Model;
@ -39,10 +38,11 @@ import com.hp.hpl.jena.sdb.sql.SDBConnection;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactoryConfig;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SingleContentOntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SparqlDatasetGraph;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SparqlGraphMultilingual;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
@ -93,7 +93,6 @@ public class WebappDaoFactorySparqlPrep implements Filter {
javax.sql.DataSource ds = JenaDataSourceSetupBase.getApplicationDataSource(_ctx);
StoreDesc storeDesc = (StoreDesc) _ctx.getAttribute("storeDesc");
OntModelSelector oms = (OntModelSelector) _ctx.getAttribute("unionOntModelSelector");
String defaultNamespace = (String) _ctx.getAttribute("defaultNamespace");
Connection sqlConn = null;
SDBConnection conn = null;
@ -102,7 +101,7 @@ public class WebappDaoFactorySparqlPrep implements Filter {
WebappDaoFactory wadf = null;
try {
if (ds == null || storeDesc == null || oms == null) {
if (ds == null || storeDesc == null) {
throw new RuntimeException("SDB store not property set up");
}
@ -147,7 +146,6 @@ public class WebappDaoFactorySparqlPrep implements Filter {
Model m = ModelFactory.createModelForGraph(g);
OntModel om = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, m);
oms = new SingleContentOntModelSelector(om, oms.getDisplayModel(), oms.getUserAccountsModel());
dataset = DatasetFactory.create(new SparqlDatasetGraph(endpointURI));
@ -156,16 +154,18 @@ public class WebappDaoFactorySparqlPrep implements Filter {
//dataset = datasource;
vreq.setAssertionsWebappDaoFactory(wadf);
ModelAccess.on(vreq).setOntModel(ModelID.UNION_ABOX, om);
ModelAccess.on(vreq).setOntModel(ModelID.UNION_TBOX, om);
ModelAccess.on(vreq).setOntModel(ModelID.UNION_FULL, om);
OntModelSelector oms = ModelAccess.on(vreq).getOntModelSelector();
wadf = new WebappDaoFactoryJena(oms, config);
//wadf = new WebappDaoFactorySDB(oms, dataset, config);
vreq.setWebappDaoFactory(wadf);
vreq.setFullWebappDaoFactory(wadf);
vreq.setUnfilteredWebappDaoFactory(wadf);
vreq.setWebappDaoFactory(wadf);
vreq.setDataset(dataset);
vreq.setJenaOntModel(om);
vreq.setOntModelSelector(oms);
}
} catch (Throwable t) {
log.error("Unable to filter request to set up SDB connection", t);

5
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ApplicationModelSetup.java
View file

@ -23,6 +23,7 @@ import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelSynchronizer;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
@ -83,7 +84,7 @@ implements ServletContextListener {
MEM_ONT_MODEL_SPEC);
appTBOXModel.add(displayTboxModel);
appTBOXModel.getBaseModel().register(new ModelSynchronizer(displayTboxModel));
ctx.setAttribute("displayOntModelTBOX", appTBOXModel);
ModelAccess.on(ctx).setOntModel(ModelID.DISPLAY_TBOX, appTBOXModel);
log.debug("Loaded file " + APPPATH_LOAD + "displayTBOX.n3 into display tbox model");
} catch (Throwable t) {
log.error("Unable to load user application configuration model TBOX", t);
@ -101,7 +102,7 @@ implements ServletContextListener {
MEM_ONT_MODEL_SPEC);
appDisplayDisplayModel.add(displayDisplayModel);
appDisplayDisplayModel.getBaseModel().register(new ModelSynchronizer(displayDisplayModel));
ctx.setAttribute("displayOntModelDisplayModel", appDisplayDisplayModel);
ModelAccess.on(ctx).setOntModel(ModelID.DISPLAY_DISPLAY, appDisplayDisplayModel);
log.debug("Loaded file " + APPPATH_LOAD + "displayDisplay.n3 into display display model");
} catch (Throwable t) {
log.error("Unable to load user application configuration model Display Model", t);

63
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ContentModelSetup.java
View file

@ -31,9 +31,8 @@ import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactoryConfig;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelSynchronizer;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelectorImpl;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceDataset;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SpecialBulkUpdateHandlerGraph;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactorySDB;
@ -72,8 +71,7 @@ public class ContentModelSetup extends JenaDataSourceSetupBase
JenaDataSourceSetupBase.thisIsFirstStartup();
}
OntModel userAccountsModel = ModelAccess.on(ctx).getUserAccountsModel();
OntModel displayModel = ModelAccess.on(ctx).getDisplayModel();
ModelAccess models = ModelAccess.on(ctx);
OntModel baseABoxModel = createNamedModelFromDataset(dataset, JENA_DB_MODEL);
OntModel inferenceABoxModel = createNamedModelFromDataset(dataset, JENA_INF_MODEL);
OntModel baseTBoxModel = createdMemoryMappedModel(dataset, JENA_TBOX_ASSERTIONS_MODEL, "tbox assertions");
@ -91,63 +89,34 @@ public class ContentModelSetup extends JenaDataSourceSetupBase
OntModel inferenceFullModel = createCombinedModel(inferenceABoxModel, inferenceTBoxModel);
OntModel unionFullModel = ModelFactory.createOntologyModel(DB_ONT_MODEL_SPEC, dataset.getDefaultModel());
ModelAccess.on(ctx).setOntModel(ModelID.APPLICATION_METADATA, applicationMetadataModel);
ModelAccess.on(ctx).setOntModel(ModelID.USER_ACCOUNTS, userAccountsModel);
ModelAccess.on(ctx).setOntModel(ModelID.DISPLAY, displayModel);
ModelAccess.on(ctx).setOntModel(ModelID.BASE_ABOX, baseABoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.BASE_TBOX, baseTBoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.BASE_FULL, baseFullModel);
ModelAccess.on(ctx).setOntModel(ModelID.INFERRED_ABOX, inferenceABoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.INFERRED_TBOX, inferenceTBoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.INFERRED_FULL, inferenceFullModel);
ModelAccess.on(ctx).setOntModel(ModelID.UNION_ABOX, unionABoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.UNION_TBOX, unionTBoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.UNION_FULL, unionFullModel);
ModelContext.setInferenceOntModel(inferenceFullModel, ctx);
models.setOntModel(ModelID.APPLICATION_METADATA, applicationMetadataModel);
models.setOntModel(ModelID.BASE_ABOX, baseABoxModel);
models.setOntModel(ModelID.BASE_TBOX, baseTBoxModel);
models.setOntModel(ModelID.BASE_FULL, baseFullModel);
models.setOntModel(ModelID.INFERRED_ABOX, inferenceABoxModel);
models.setOntModel(ModelID.INFERRED_TBOX, inferenceTBoxModel);
models.setOntModel(ModelID.INFERRED_FULL, inferenceFullModel);
models.setOntModel(ModelID.UNION_ABOX, unionABoxModel);
models.setOntModel(ModelID.UNION_TBOX, unionTBoxModel);
models.setOntModel(ModelID.UNION_FULL, unionFullModel);
checkForNamespaceMismatch( applicationMetadataModel, ctx );
OntModelSelectorImpl baseOms = new OntModelSelectorImpl();
baseOms.setApplicationMetadataModel(applicationMetadataModel);
baseOms.setUserAccountsModel(userAccountsModel);
baseOms.setDisplayModel(displayModel);
baseOms.setABoxModel(baseABoxModel);
baseOms.setTBoxModel(baseTBoxModel);
baseOms.setFullModel(baseFullModel);
OntModelSelectorImpl inferenceOms = new OntModelSelectorImpl();
inferenceOms.setApplicationMetadataModel(applicationMetadataModel);
inferenceOms.setUserAccountsModel(userAccountsModel);
inferenceOms.setDisplayModel(displayModel);
inferenceOms.setABoxModel(inferenceABoxModel);
inferenceOms.setTBoxModel(inferenceTBoxModel);
inferenceOms.setFullModel(inferenceFullModel);
OntModelSelectorImpl unionOms = new OntModelSelectorImpl();
unionOms.setApplicationMetadataModel(applicationMetadataModel);
unionOms.setUserAccountsModel(userAccountsModel);
unionOms.setDisplayModel(displayModel);
unionOms.setABoxModel(unionABoxModel);
unionOms.setTBoxModel(unionTBoxModel);
unionOms.setFullModel(unionFullModel);
ModelContext.setOntModelSelector(unionOms, ctx);
ModelContext.setUnionOntModelSelector(unionOms, ctx); // assertions and inferences
ModelContext.setBaseOntModelSelector(baseOms, ctx); // assertions
ModelContext.setInferenceOntModelSelector(inferenceOms, ctx); // inferences
log.info("Setting up DAO factories");
WebappDaoFactoryConfig config = new WebappDaoFactoryConfig();
config.setDefaultNamespace(getDefaultNamespace(ctx));
OntModelSelector baseOms = models.getBaseOntModelSelector();
WebappDaoFactory baseWadf = new WebappDaoFactorySDB(rdfService, baseOms, config, ASSERTIONS_ONLY);
ctx.setAttribute("assertionsWebappDaoFactory",baseWadf);
OntModelSelector inferenceOms = models.getInferenceOntModelSelector();
WebappDaoFactory infWadf = new WebappDaoFactorySDB(rdfService, inferenceOms, config, INFERENCES_ONLY);
ctx.setAttribute("deductionsWebappDaoFactory", infWadf);
OntModelSelector unionOms = models.getUnionOntModelSelector();
WebappDaoFactory wadf = new WebappDaoFactorySDB(rdfService, unionOms, config);
ctx.setAttribute("webappDaoFactory",wadf);

14
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/FileGraphSetup.java
View file

@ -26,7 +26,7 @@ import com.hp.hpl.jena.query.Dataset;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceModelMaker;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils;
@ -48,16 +48,16 @@ public class FileGraphSetup implements ServletContextListener {
boolean tboxChanged = false; // indicates whether any TBox file graph model has changed
OntModelSelector baseOms = null;
ServletContext ctx = sce.getServletContext();
try {
ServletContext ctx = sce.getServletContext();
OntDocumentManager.getInstance().setProcessImports(true);
baseOms = ModelContext.getBaseOntModelSelector(sce.getServletContext());
Dataset dataset = JenaDataSourceSetupBase.getStartupDataset(sce.getServletContext());
baseOms = ModelAccess.on(ctx).getBaseOntModelSelector();
Dataset dataset = JenaDataSourceSetupBase.getStartupDataset(ctx);
RDFServiceModelMaker maker = new RDFServiceModelMaker(RDFServiceUtils.getRDFServiceFactory(ctx));
// ABox files
Set<String> pathSet = sce.getServletContext().getResourcePaths(PATH_ROOT + ABOX);
Set<String> pathSet = ctx.getResourcePaths(PATH_ROOT + ABOX);
cleanupDB(dataset, pathToURI(pathSet, ABOX), ABOX);
@ -67,7 +67,7 @@ public class FileGraphSetup implements ServletContextListener {
}
// TBox files
pathSet = sce.getServletContext().getResourcePaths(PATH_ROOT + TBOX);
pathSet = ctx.getResourcePaths(PATH_ROOT + TBOX);
cleanupDB(dataset, pathToURI(pathSet, TBOX),TBOX);

12
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/SimpleReasonerSetup.java
View file

@ -22,7 +22,7 @@ import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.vocabulary.OWL;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceDataset;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
@ -33,7 +33,6 @@ import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils;
import edu.cornell.mannlib.vitro.webapp.reasoner.ReasonerPlugin;
import edu.cornell.mannlib.vitro.webapp.reasoner.SimpleReasoner;
import edu.cornell.mannlib.vitro.webapp.reasoner.SimpleReasonerTBoxListener;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase.TripleStoreType;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
public class SimpleReasonerSetup implements ServletContextListener {
@ -48,13 +47,13 @@ public class SimpleReasonerSetup implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
ServletContext ctx = sce.getServletContext();
try {
// set up Pellet reasoning for the TBox
OntModelSelector assertionsOms = ModelContext.getBaseOntModelSelector(sce.getServletContext());
OntModelSelector inferencesOms = ModelContext.getInferenceOntModelSelector(sce.getServletContext());
OntModelSelector unionOms = ModelContext.getUnionOntModelSelector(sce.getServletContext());
OntModelSelector assertionsOms = ModelAccess.on(ctx).getBaseOntModelSelector();
OntModelSelector inferencesOms = ModelAccess.on(ctx).getInferenceOntModelSelector();
OntModelSelector unionOms = ModelAccess.on(ctx).getUnionOntModelSelector();
WebappDaoFactoryJena wadf = (WebappDaoFactoryJena) sce.getServletContext().getAttribute("webappDaoFactory");
@ -83,7 +82,6 @@ public class SimpleReasonerSetup implements ServletContextListener {
// set up simple reasoning for the ABox
ServletContext ctx = sce.getServletContext();
DataSource bds = JenaDataSourceSetupBase
.getApplicationDataSource(ctx);
String dbType = ConfigurationProperties.getBean(ctx).getProperty( // database type

5
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ThemeInfoSetup.java
View file

@ -23,7 +23,9 @@ import com.hp.hpl.jena.util.iterator.ClosableIterator;
import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean;
import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean.ThemeInfo;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
@ -91,8 +93,7 @@ public class ThemeInfoSetup implements ServletContextListener {
}
private String getCurrentThemeName(ServletContext ctx) {
OntModel ontModel = ModelContext.getBaseOntModelSelector(ctx)
.getApplicationMetadataModel();
OntModel ontModel = ModelAccess.on(ctx).getApplicationMetadataModel();
ontModel.enterCriticalSection(Lock.READ);
try {

7
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/UpdateKnowledgeBase.java
View file

@ -34,7 +34,6 @@ import com.hp.hpl.jena.vocabulary.RDFS;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.ontology.update.KnowledgeBaseUpdater;
import edu.cornell.mannlib.vitro.webapp.ontology.update.UpdateSettings;
@ -102,9 +101,9 @@ public class UpdateKnowledgeBase implements ServletContextListener {
settings.setRemovedDataFile(ctx.getRealPath(REMOVED_DATA_FILE));
WebappDaoFactory wadf = (WebappDaoFactory) ctx.getAttribute("webappDaoFactory");
settings.setDefaultNamespace(wadf.getDefaultNamespace());
settings.setAssertionOntModelSelector(ModelContext.getBaseOntModelSelector(ctx));
settings.setInferenceOntModelSelector(ModelContext.getInferenceOntModelSelector(ctx));
settings.setUnionOntModelSelector(ModelContext.getUnionOntModelSelector(ctx));
settings.setAssertionOntModelSelector(ModelAccess.on(ctx).getBaseOntModelSelector());
settings.setInferenceOntModelSelector(ModelAccess.on(ctx).getInferenceOntModelSelector());
settings.setUnionOntModelSelector(ModelAccess.on(ctx).getUnionOntModelSelector());
boolean tryMigrateDisplay = true;
try {
settings.setDisplayModel(ModelAccess.on(ctx).getDisplayModel());

4
webapp/src/edu/cornell/mannlib/vitro/webapp/utils/ApplicationConfigurationOntologyUtils.java
View file

@ -24,7 +24,7 @@ import com.hp.hpl.jena.rdf.model.Resource;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectProperty;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
public class ApplicationConfigurationOntologyUtils {
@ -33,7 +33,7 @@ public class ApplicationConfigurationOntologyUtils {
public static List<ObjectProperty> getAdditionalFauxSubpropertiesForList(List<ObjectProperty> propList, VitroRequest vreq) {
ServletContext ctx = vreq.getSession().getServletContext();
Model displayModel = ModelAccess.on(ctx).getDisplayModel();
Model tboxModel = ModelContext.getUnionOntModelSelector(ctx).getTBoxModel();
Model tboxModel = ModelAccess.on(ctx).getOntModel(ModelID.UNION_TBOX);
return getAdditionalFauxSubpropertiesForList(propList, displayModel, tboxModel);
}