Metacat

    private static final String WT = "wt";//the property name to specify the return type

    private static List<String> supportedWriterTypes = null;

    private static final String VERSION = "3.4";

    private static final String SOLRCONFDIR = "/conf";

    private static final String SOLRSCHEMAFILEPATH = SOLRCONFDIR+"/schema.xml";

    private static final String FILTERQUERY = "fq";

    private static final String READPERMISSION = "readPermission";

    private static final String RIGHTSHOLDER = "rightsHolder";

    private static final String OPENPARENTHESE = "(";

    private static final String CLOSEPARENTHESE = ")";

    private static final String COLON = ":";

    private static final String OR = "OR";

    //private static final String SOLRCONFIGPATH = "/conf/solrconfig.xml";

    private CoreContainer coreContainer = null;

    private SolrServer solrServer = null;

    //private String wt = null;//specify the return format.

    private String collectionName = null;

    private String solrBaseURL = null;

    private boolean isEmbeddedSolrServer = true;

    	// these are handled directly by solr

    	supportedWriterTypes = new ArrayList<String>();

    	supportedWriterTypes.add(SolrQueryResponseWriterFactory.CSV);

    	supportedWriterTypes.add(SolrQueryResponseWriterFactory.JSON);

    	supportedWriterTypes.add(SolrQueryResponseWriterFactory.PHP);

    	supportedWriterTypes.add(SolrQueryResponseWriterFactory.PHPS);

    	supportedWriterTypes.add(SolrQueryResponseWriterFactory.RUBY);

    	supportedWriterTypes.add(SolrQueryResponseWriterFactory.VELOCITY);

    	supportedWriterTypes.add(SolrQueryResponseWriterFactory.PYTHON);

    	supportedWriterTypes.add(SolrQueryResponseWriterFactory.XML);

        generateSolrServer();

    /*

     * Generate the embedded solr server

     */

    private void generateSolrServer() throws Exception {

        solrServer = SolrServerFactory.createSolrServer();

        if(solrServer instanceof EmbeddedSolrServer) {

            isEmbeddedSolrServer = true;

            coreContainer = SolrServerFactory.getCoreContainer();

            collectionName = SolrServerFactory.getCollectionName();

        } else {

            isEmbeddedSolrServer = false;

            CommonsHttpSolrServer httpServer = (CommonsHttpSolrServer)solrServer;

            solrBaseURL = httpServer.getBaseURL();

        }

    }

    public InputStream query(String query, Set<Subject>authorizedSubjects) throws SolrServerException, IOException, PropertyNotFoundException, SQLException, ClassNotFoundException, ParserConfigurationException, SAXException {

        if(isEmbeddedSolrServer) {

            return queryEmbedded(query, authorizedSubjects);

        } else {

            return queryHttp(query, authorizedSubjects);

        }

    }

    /**

     * Query a solr embedded server

     * @param query  the solr query

     * @return the result as the InputStream

     * @throws SolrServerException 

     * @throws ClassNotFoundException 

     * @throws SQLException 

     * @throws PropertyNotFoundException 

     * @throws SAXException 

     * @throws ParserConfigurationException 

     */

    private InputStream queryEmbedded(String query, Set<Subject>subjects) throws SolrServerException, IOException, PropertyNotFoundException, SQLException, ClassNotFoundException, ParserConfigurationException, SAXException {

        solrParams = appendAccessFilterParams(solrParams, subjects);

        String wt = solrParams.get(WT);

        //reload the core before query. Only after reloading the core, the query result can reflect the change made in metacat-index module.

        coreContainer.reload(collectionName);

        SolrCore core = coreContainer.getCore(collectionName);

        SolrQueryResponseTransformer solrTransformer = new SolrQueryResponseTransformer(core);

        if (wt == null ||supportedWriterTypes.contains(wt)) {

        	// just handle as normal solr query

	        QueryResponse response = solrServer.query(solrParams);

	        inputStream = solrTransformer.transformResults(solrParams, response, wt);

        	// assume it is a skin name

        	String qformat = wt;

        	// perform the solr query using wt=XML

        	wt = SolrQueryResponseWriterFactory.XML;

        	ModifiableSolrParams msp = new ModifiableSolrParams(solrParams);

        	msp.set(WT, wt);

        	QueryResponse response = solrServer.query(msp);

	        inputStream = solrTransformer.transformResults(msp, response, wt);

	        // apply the stylesheet (XML->HTML)

	        DBTransform transformer = new DBTransform();

	        String documentContent = IOUtils.toString(inputStream, "UTF-8");

			String sourceType = "solr";

			String targetType = "-//W3C//HTML//EN";

			ByteArrayOutputStream baos = new ByteArrayOutputStream();

			Writer writer = new OutputStreamWriter(baos , "UTF-8");

			// TODO: include more params?

			Hashtable<String, String[]> params = new Hashtable<String, String[]>();

			params.put("qformat", new String[] {qformat});

			transformer.transformXMLDocument(

	        		documentContent , 

	        		sourceType, 

	        		targetType , 

	        		qformat, 

	        		writer, 

	        		params, 

	        		null //sessionid

	        		);

			// finally, get the HTML back

			inputStream = new ByteArrayInputStream(baos.toByteArray());	

    /*

     * Query a http server. We directly build the url to send the http server.

     * The reason we don't use the method is:

     * QueryResponse response = solrServer.query(solrParams);

     * When we transform the QueryReponse object to the InputStream object, we need to have SolrCore object 

     * which is not available for the SolrHttpServer.

     * 

     */

    private InputStream queryHttp(String query, Set<Subject>subjects) throws IOException {

        StringBuffer accessFilter = generateAccessFilterParamsString(subjects);

        if(accessFilter != null && accessFilter.length() != 0) {

            query = solrBaseURL+"/select?"+query+"&"+FILTERQUERY+"="+accessFilter.toString();

        }

        URL url = new URL(query);

        return url.openStream();

    }

    /*

     * Append the access filter query to the params

     */

    private SolrParams appendAccessFilterParams(SolrParams solrParams, Set<Subject>subjects) {

        SolrParams append = null;

        if(solrParams != null) {

            StringBuffer query = generateAccessFilterParamsString(subjects);      

            if(query != null && query.length() != 0) {

                log.info("=================== fq query is "+query.toString());

                NamedList fq = new NamedList();

                fq.add(FILTERQUERY, query.toString());

                SolrParams fqParam = SolrParams.toSolrParams(fq);

                append = new AppendedSolrParams(solrParams, fqParam);

            } else {

                append = solrParams;

            }

        }

        return append;

    }

    private StringBuffer generateAccessFilterParamsString(Set<Subject>subjects) {

        StringBuffer query = new StringBuffer();

        boolean first = true;

        if(subjects != null) {

            for(Subject subject : subjects) {

                if(subject != null) {

                    String subjectName = subject.getValue();

                    if(subjectName != null && !subjectName.trim().equals("")) {

                        if(first) {

                            first = false;

                            query.append(OPENPARENTHESE+READPERMISSION+COLON+"\""+subjectName+"\""+CLOSEPARENTHESE);

                            if(!subjectName.equals(Constants.SUBJECT_PUBLIC) && !subjectName.equals(Constants.SUBJECT_AUTHENTICATED_USER)) {

                                query.append(OR+OPENPARENTHESE+RIGHTSHOLDER+COLON+"\""+subjectName+"\""+CLOSEPARENTHESE);

                            }

                        } else {

                            query.append(OR + OPENPARENTHESE+READPERMISSION+COLON+"\""+subjectName+"\""+CLOSEPARENTHESE);

                            if(!subjectName.equals(Constants.SUBJECT_PUBLIC) && !subjectName.equals(Constants.SUBJECT_AUTHENTICATED_USER)) {

                                query.append(OR + OPENPARENTHESE+RIGHTSHOLDER+COLON+"\""+subjectName+"\""+CLOSEPARENTHESE);

                            }

                        }

                    }

                }

            }

        }

        return query;

    }