0.8.1-rc1/filemgr/src/main/java/org/apache/oodt/cas/filemgr/tools/CatalogSearch.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.oodt.cas.filemgr.tools;

//OODT imports
import org.apache.oodt.cas.filemgr.structs.Element;
import org.apache.oodt.cas.filemgr.structs.Product;
import org.apache.oodt.cas.filemgr.structs.ProductType;
import org.apache.oodt.cas.filemgr.structs.RangeQueryCriteria;
import org.apache.oodt.cas.filemgr.structs.TermQueryCriteria;
import org.apache.oodt.cas.filemgr.structs.exceptions.CatalogException;
import org.apache.oodt.cas.filemgr.structs.exceptions.RepositoryManagerException;
import org.apache.oodt.cas.filemgr.structs.exceptions.ValidationLayerException;
import org.apache.oodt.cas.filemgr.system.XmlRpcFileManagerClient;

//JDK imports
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.StringTokenizer;
import java.util.Vector;

//Lucene imports
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.RangeQuery;
import org.apache.lucene.search.TermQuery;

/**
 * 
 * @author woollard
 * @version $Revision$
 * 
 * <p>
 * A command line-search tool for the File Manager.
 * </p>
 * 
 */
public class CatalogSearch {

    private static QueryParser parser;

    private static XmlRpcFileManagerClient client;

    private static String freeTextBlock = "__FREE__";

    private static String productFilter = "";

    public CatalogSearch() {
    }

    public static void PostQuery(
            org.apache.oodt.cas.filemgr.structs.Query casQuery) {
        Vector products = new Vector();
        try {
            products = (Vector) client.getProductTypes();
        } catch (RepositoryManagerException e) {
            System.out
                    .println("Error getting available product types from the File Manager.");
            e.printStackTrace();
        }
        for (int i = 0; i < products.size(); i++) {
            PostQuery(((ProductType) products.get(i)).getProductTypeId(),
                    casQuery);
        }
    }

    public static void PostQuery(String product,
            org.apache.oodt.cas.filemgr.structs.Query casQuery) {
        Vector results = new Vector();
        ProductType productType = null;

        try {
            productType = client.getProductTypeById(product);
        } catch (RepositoryManagerException e) {
            System.out.println("Could not access Product Type information");
            System.exit(-1);
        }

        try {
            results = (Vector) client.query(casQuery, productType);
        } catch (CatalogException ignore) {
            System.out.println("Error querying the File Manager");
            ignore.printStackTrace();
            System.exit(-1);
        }

        if (results.isEmpty()) {
            System.out.println("No Products Found Matching This Criteria.");
        } else {
            System.out.println("Products Matching Query");
            for (int i = 0; i < results.size(); i++) {
                System.out.print(((Product) results.get(i)).getProductName()
                        + "\t");
                System.out.println(((Product) results.get(i)).getProductId());
            }
        }
    }

    public static void setFilter(String filter) {
        productFilter = filter;
        try {
            client.getProductTypeById(filter);
        } catch (RepositoryManagerException e) {
            System.out.println("No product found with ID: " + filter);
            productFilter = "";
        }
        if (!productFilter.equals(""))
            System.out.println("Filtering for " + productFilter + " products.");
    }

    public static void removeFilter() {
        productFilter = "";
    }

    public static void ListProducts() {
        Vector products = new Vector();
        try {
            products = (Vector) client.getProductTypes();
        } catch (RepositoryManagerException e) {
            System.out
                    .println("Error getting available product types from the File Manager.");
            e.printStackTrace();
        }
        for (int i = 0; i < products.size(); i++) {
            System.out.print(((ProductType) products.get(i)).getProductTypeId()
                    + "\t");
            System.out.println(((ProductType) products.get(i)).getName());
        }
    }

    public static void listElements() {
        Vector products = new Vector();
        try {
            products = (Vector) client.getProductTypes();
            for (int i = 0; i < products.size(); i++) {
                listElements(((ProductType) products.get(i)).getProductTypeId());
            }
        } catch (RepositoryManagerException e) {
            System.out
                    .println("Error getting available product types from the File Manager.");
            e.printStackTrace();
        }

    }

    public static void listElements(String prodID) {
        Vector elements = new Vector();
        ProductType type;

        try {
            type = client.getProductTypeById(prodID);
            elements = (Vector) client.getElementsByProductType(type);
        } catch (RepositoryManagerException e1) {
            System.out.println("Could not find a ProductType with the ID: "
                    + prodID);
        } catch (ValidationLayerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < elements.size(); i++) {
            Element e = (Element) elements.get(i);
            System.out.print(e.getElementId() + "\t");
            System.out.println(e.getElementName());
        }
    }

    public static void printHelp() {
        String add_filter = "add filter [productType]\n";
        add_filter += "\tAdd a filter on query results to only return products\n";
        add_filter += "\tmatching the specified productType.";

        String remove_filter = "remove filter\n";
        remove_filter += "\tRemove filters on query results.";

        String get_products = "get products\n";
        get_products += "\tReturns all ProductTypeIDs known to the Repository.";

        String get_elements = "get elements\n";
        get_elements += "\tReturns all Elements known to the Validation Layer.";

        String get_elements_for_product = "get elements for [productType]\n";
        get_elements_for_product += "\tReturns all Elements known to the ";
        get_elements_for_product += "Validation Layer\n\tfor the specified ";
        get_elements_for_product += "productType.";

        String query = "query [query]\n";
        query += "\tQueries the Catalog for all products matching the \n";
        query += "\tspecified query. If the filter is set, only products\n";
        query += "\tmatching the productType set in the filter will be\n";
        query += "\treturned. More details about query syntax can be found\n";
        query += "\tat http://lucene.apache.org/java/docs/queryparsersyntax.html";

        String quit = "quit\n";
        quit += "\tExits the program.";

        System.out.println("Available Commands:");
        System.out.println(add_filter);
        System.out.println(remove_filter);
        System.out.println(get_products);
        System.out.println(get_elements);
        System.out.println(get_elements_for_product);
        System.out.println(query);
        System.out.println(quit);
    }

    public static Query ParseQuery(String query) {
        // note that "__FREE__" is a control work for free text searching
        parser = new QueryParser(freeTextBlock, new CASAnalyzer());
        Query luceneQ = null;
        try {
            luceneQ = (Query) parser.parse(query);
        } catch (ParseException e) {
            System.out.println("Error parsing query text.");
            System.exit(-1);
        }
        return luceneQ;
    }

    public static void GenerateCASQuery(
            org.apache.oodt.cas.filemgr.structs.Query casQuery,
            Query luceneQuery) {
        if (luceneQuery instanceof TermQuery) {
            Term t = ((TermQuery) luceneQuery).getTerm();
            if (t.field().equals(freeTextBlock)) {
                // if(casQuery.getCriteria().isEmpty())
                // casQuery.addCriterion(new FreeTextQueryCriteria());
                // ((FreeTextQueryCriteria)casQuery.getCriteria().get(0)).addValue(t.text());
            } else {
                casQuery
                        .addCriterion(new TermQueryCriteria(t.field(), t.text()));
            }
        } else if (luceneQuery instanceof PhraseQuery) {
            Term[] t = ((PhraseQuery) luceneQuery).getTerms();
            if (t[0].field().equals(freeTextBlock)) {
                // if(casQuery.getCriteria().isEmpty())
                // casQuery.addCriterion(new FreeTextQueryCriteria());
                // for(int i=0;i<t.length;i++)
                // ((FreeTextQueryCriteria)casQuery.getCriteria().get(0)).addValue(t[i].text());
            } else {
                for (int i = 0; i < t.length; i++)
                    casQuery.addCriterion(new TermQueryCriteria(t[i].field(),
                            t[i].text()));
            }
        } else if (luceneQuery instanceof RangeQuery) {
            Term startT = ((RangeQuery) luceneQuery).getLowerTerm();
            Term endT = ((RangeQuery) luceneQuery).getUpperTerm();
            casQuery.addCriterion(new RangeQueryCriteria(startT.field(), startT
                    .text(), endT.text()));
        } else if (luceneQuery instanceof BooleanQuery) {
            BooleanClause[] clauses = ((BooleanQuery) luceneQuery).getClauses();
            for (int i = 0; i < clauses.length; i++) {
                GenerateCASQuery(casQuery, (clauses[i]).getQuery());
            }
        } else {
            System.out.println("Error Parsing Query");
            System.exit(-1);
        }
    }

    public static void CommandParser(String command) {
        StringTokenizer tok = new StringTokenizer(command, " ");
        int tokCount = tok.countTokens();

        if (tokCount > 0) {
            String com = tok.nextToken();
            if (com.equalsIgnoreCase("get")) {
                if (tokCount > 1) {
                    String subcom = tok.nextToken();
                    if (subcom.equalsIgnoreCase("products")) {
                        ListProducts();
                    } else if (subcom.equalsIgnoreCase("elements")) {
                        if (tokCount == 4
                                && tok.nextToken().equalsIgnoreCase("for")) {
                            String prodElements = tok.nextToken();
                            listElements(prodElements);
                        } else {
                            if (tokCount == 2) {
                                listElements();
                            } else {
                                System.out.println("Error parsing command");
                                return;
                            }
                        }
                    }
                } else {
                    System.out.println("Error parsing command");
                    return;
                }
            } else if (com.equalsIgnoreCase("add")) {
                if (tokCount == 3 && tok.nextToken().equalsIgnoreCase("filter")) {
                    setFilter(tok.nextToken());
                } else {
                    System.out.println("Error parsing command");
                    return;
                }
            } else if (com.equalsIgnoreCase("remove")) {
                if (tokCount == 2 && tok.nextToken().equalsIgnoreCase("filter")) {
                    removeFilter();
                } else {
                    System.out.println("Error parsing command");
                    return;
                }
            } else if (com.equalsIgnoreCase("help")) {
                printHelp();
            } else if (com.equalsIgnoreCase("exit")
                    || com.equalsIgnoreCase("quit")) {
                System.out.println("Exiting...");
                System.exit(0);
            } else if (com.equalsIgnoreCase("query")) {
                String query = new String();
                while (tok.hasMoreTokens()) {
                    query += tok.nextToken() + " ";
                }
                System.out.println("querying for: " + query);
                Query parsedQuery = ParseQuery(query);
                org.apache.oodt.cas.filemgr.structs.Query casQuery = new org.apache.oodt.cas.filemgr.structs.Query();

                GenerateCASQuery(casQuery, parsedQuery);
                PostQuery(productFilter, casQuery);
            }
        }
    }

    public static void main(String[] args) {

        String fileManagerUrl = null;
        String welcomeMessage = "CatalogSearch v0.1\n";
        welcomeMessage += "Copyright 2006. California Institute of Technology.\n";
        String usage = "CatalogSearch --url <url to File Manager service>\n";
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        CatalogSearch cs = new CatalogSearch();

        // determine url
        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("--url")) {
                fileManagerUrl = args[++i];
            }
        }

        if (fileManagerUrl == null) {
            System.err.println(usage);
            System.exit(1);
        }

        // connect with Filemgr Client
        boolean clientConnect = true;
        try {
            client = new XmlRpcFileManagerClient(new URL(fileManagerUrl));
        } catch (Exception e) {
            System.out
                    .println("Exception when communicating with file manager, errors to follow: message: "
                            + e.getMessage());
            clientConnect = false;
        }

        if (clientConnect) {

            System.out.println(welcomeMessage);

            String command = "";

            for (;;) {
                System.out.print("CatalogSearch>");

                try {
                    command = in.readLine();
                    CommandParser(command);

                } catch (IOException e) {
                    System.out.println("\nError Reading Query\n");
                    System.exit(-1);
                }
            }
        }
    }

}