source: trunk/greenstone3-extensions/gsdl-as/src/org/greenstone/gsdlas/ProfileStore.java@ 8798

/*
 * Created on Oct 27, 2004
 * Copyright (C) Andrea Schweer, 2004
 *
 * This file is part of the Greenstone Alerting Service.
 * Refer to the COPYING file in the base directory of this package
 * for licensing information.
 */
package org.greenstone.gsdlas;

import java.sql.*;
import java.sql.Connection;
import java.sql.Statement;
import java.util.*;

import javax.servlet.http.HttpSession;

import org.greenstone.gsdlas.database.DatabaseException;
import org.greenstone.gsdlas.database.DatabaseManager;
import org.greenstone.gsdlas.profiles.*;

/**
 * Storage for all Profiles. Singleton.
 * 
 * @author schweer
 *  
 */
public class ProfileStore {

    private static ProfileStore instance;

    private Set noEqualsSubscriptions = new TreeSet();
    private Map dontCareSubscriptions = new TreeMap();
    private Map subscriptions = new TreeMap();
    

    private ProfileStore() {
        // TODO restore subscriptions from database
    }

    /**
     * @return the one existing instance of this class.
     */
    public static ProfileStore getInstance() {
        if (instance == null) {
            instance = new ProfileStore();
        }
        return instance;
    }

    /**
     * @param subscription
     *            the subscription to add to the profile store.
     */
    private void addSubscription(Subscription subscription) {
        // TODO change to lists
        List documentIdPredicate = subscription.getPredicateList("documentID");
        List collectionIdPredicate = subscription.getPredicateList("collectionID");
        List hostIdPredicate = subscription.getPredicateList("hostID");
        List typePredicate = subscription.getPredicateList("type");
        
        Integer subId = new Integer(subscription.getId());
        
        if (documentIdPredicate.isEmpty()) {
            if (!dontCareSubscriptions.containsKey("documentID")) {
                dontCareSubscriptions.put("documentID", new TreeSet());
            }
            Set list = (Set) dontCareSubscriptions.get("documentID");
            list.add(subId);
        }
        if (collectionIdPredicate.isEmpty()) {
            if (!dontCareSubscriptions.containsKey("collectionID")) {
                dontCareSubscriptions.put("collectionID", new TreeSet());
            }
            Set list = (Set) dontCareSubscriptions.get("collectionID");
            list.add(subId);
        }
        if (hostIdPredicate.isEmpty()) {
            if (!dontCareSubscriptions.containsKey("hostID")) {
                dontCareSubscriptions.put("hostID", new TreeSet());
            }
            Set list = (Set) dontCareSubscriptions.get("hostID");
            list.add(subId);
        }
        if (typePredicate.isEmpty()) {
            if (!dontCareSubscriptions.containsKey("type")) {
                dontCareSubscriptions.put("type", new TreeSet());
            }
            Set list = (Set) dontCareSubscriptions.get("type");
            list.add(subId);
        }
        
        if (documentIdPredicate.isEmpty() && collectionIdPredicate.isEmpty() 
                && hostIdPredicate.isEmpty() && typePredicate.isEmpty()) {
            noEqualsSubscriptions.add(subId);
        }
        subscriptions.put(subId, subscription);
    }

    /**
     * @return
     */
    public Set getSubscriptionsWithoutEqualsPredicates() {
        return Collections.unmodifiableSet(noEqualsSubscriptions);
    }

    /**
     * Computes the list of equality subscriptions satisfied by the event.
     * @param event
     * @return
     */
    public Set getPartiallyMatchedSubscriptions(Map event) {
        Set result = new TreeSet();
        // TODO rework algo for getting partially matched subs
        IdEqualsPredicate predicate;
        predicate = PredicateFactory.getIdEqualsPredicate("type", (String)event.get("type"));
        if (predicate != null)
            result.addAll(predicate.getSubscriptionIDs());
        
        Set docIDSubs = new TreeSet();
        predicate = PredicateFactory.getIdEqualsPredicate("documentID", (String)event.get("documentID"));
        if (predicate != null)
            docIDSubs.addAll(predicate.getSubscriptionIDs());
        docIDSubs.addAll(getDontCareSubscriptions("documentID"));
        result.retainAll(docIDSubs);
        
        Set collIDSubs = new TreeSet();
        predicate = PredicateFactory.getIdEqualsPredicate("collectionID", (String)event.get("collectionID"));
        if (predicate != null)
            collIDSubs.addAll(predicate.getSubscriptionIDs());
        collIDSubs.addAll(getDontCareSubscriptions("collectionID"));
        result.retainAll(collIDSubs);
        
        Set hostIDSubs = new TreeSet();
        predicate = PredicateFactory.getIdEqualsPredicate("hostID", (String)event.get("hostID"));
        if (predicate != null)
            hostIDSubs.addAll(predicate.getSubscriptionIDs());
        hostIDSubs.addAll(getDontCareSubscriptions("hostID"));
        result.retainAll(hostIDSubs);
        
        return result;
    }

    /**
     * 
     * @param gsComm 
     * @return
     * @throws UnsupportedFieldException
     */
    private Set findMatchedQueryPredicates(Map event, GreenstoneCommunicator gsComm) {
        Set matchedPreds = new TreeSet();
        
        // iterate through all document content predicates
        // execute the query stored in the predicate
        // predicate is matched iff the docID occurs in the query result
        
        for (Iterator iter = PredicateFactory.getQueryPredicates("document_content").iterator(); iter.hasNext();) {
            Predicate predicate = (Predicate) iter.next();
            String collection = (String) event.get("collectionID");
            String query = predicate.getValue();
            Set results;
            try {
                results = gsComm.fullTextSearch(collection, query);
                if (results.contains(event.get("documentID"))) {
                    matchedPreds.add(predicate);
                }
            } catch (Exception e) {
            }
        }
        
        return matchedPreds;
    }

    /**
     * Computes the set of SubstringMatchPredicates satisfied by the event.
     * @param event
     * 
     * @return
     */
    private Set findMatchedSubstringMatchPredicates(Map event) {
        Set result = new TreeSet();
        
        for (Iterator iter = PredicateFactory.getAllSubstringMatchPredicates().iterator(); iter.hasNext();) {
            Predicate predicate = (Predicate) iter.next();
            if (predicate.isSatisfied(event)) {
                result.add(predicate);
            }
        }
        return result;
    }

    /**
     * Filters the event against the profiles. It uses the equality-preferred
     * algorithm as described in Fabret, Llirbat, Pereira and Shasha:
     * <em>Efficient Matching for Content-based Publish/Subscribe 
     * Systems</em>.
     * @param event
     * @param gsComm 
     */
    public Set filter(Map event, GreenstoneCommunicator gsComm) {
        Set matchedSubscriptions = new TreeSet();
    
        Set partiallyMatchedSubscriptions 
            = getPartiallyMatchedSubscriptions(event);
    
        Set matchedPredicates = findMatchedSubstringMatchPredicates(event);
        matchedPredicates.addAll(findMatchedQueryPredicates(event, gsComm));
    
        Map numMatchedPredicates = new TreeMap();
        for (Iterator iter = matchedPredicates.iterator(); iter.hasNext();) {
            Predicate pred = (Predicate) iter.next();
            for (Iterator iterator = pred.getSubscriptionIDs().iterator(); iterator
                    .hasNext();) {
                Integer subId = (Integer) iterator.next();
                Subscription sub = (Subscription) subscriptions.get(subId);
                Integer count = (Integer) numMatchedPredicates.get(subId);
                int newCountValue = (count == null ? 1 : count.intValue() + 1);
                numMatchedPredicates.put(subId,
                        new Integer(newCountValue));
            }
        }
    
        Set notUnmatchedSubscriptions = partiallyMatchedSubscriptions;
        notUnmatchedSubscriptions.addAll(noEqualsSubscriptions);
        for (Iterator iter = notUnmatchedSubscriptions.iterator(); iter
                .hasNext();) {
            Integer subId = (Integer) iter.next();
            Subscription sub = (Subscription) subscriptions.get(subId);
            int matchedPredicatesCount = 0;
            if (numMatchedPredicates.get(subId) != null) {
                matchedPredicatesCount = ((Integer) numMatchedPredicates.get(subId)).intValue();
            }
            if (matchedPredicatesCount == sub.getNumOfNonEqualsPredicates()) {
                matchedSubscriptions.add(sub);
            }
        }
        return matchedSubscriptions;
    }
//
//    public String toString() {
//        Set allSubscriptions = getAllSubscriptions();
//        
//        StringBuffer buffer = new StringBuffer();
//        
//        for (Iterator iter = allSubscriptions.iterator(); iter.hasNext();) {
//            Subscription sub = (Subscription) iter.next();
//            buffer.append(sub);
//            buffer.append("\n");
//        }
//        
//        return buffer.toString();
//    }
//
//    /**
//     * @return
//     */
//    public Set getAllSubscriptions() {
//        Set allSubscriptions = new TreeSet();
//        allSubscriptions.addAll(noEqualsSubscriptions);
//        
//        for(Iterator iter = docIdEqualsSubscriptions.values().iterator(); iter.hasNext();) {
//            Set values = (Set) iter.next();
//            allSubscriptions.addAll(values);
//        }
//        
//        for(Iterator iter = docCollectionIdEqualsSubscriptions.values().iterator(); iter.hasNext();) {
//            Set values = (Set) iter.next();
//            allSubscriptions.addAll(values);
//        }
//        
//        for(Iterator iter = collectionIdEqualsSubscriptions.values().iterator(); iter.hasNext();) {
//            Set values = (Set) iter.next();
//            allSubscriptions.addAll(values);
//        }
//        return Collections.unmodifiableSet(allSubscriptions);
//    }


    /**
     * @param arguments
     * @throws Exception
     */
    public void createSubscription(Map arguments) throws Exception {
        Subscription sub = new Subscription(arguments);
        addSubscription(sub);
    }

    
    /**
     * @param subscriptionID
     */
    public void deleteSubscription(String subscriptionID) {
        // delete row from subscriptions table 
        // for each predicate:
        // delete row from subs_to_predicates
        // if there aren't any other subscriptions using this predicate, delete predicate
        // TODO Auto-generated method stub
        
    }

    /**
     * @param arguments
     * @param session
     */
    public void changeSubscription(Map arguments, HttpSession session) {
        String subscriptionID = (String) arguments.get("subscriptionID");
        // TODO Auto-generated method stub
        
    }

    /**
     * @param username
     * @return
     * @throws DatabaseException
     */
    public Set getAllSubscriptionsFor(String username) throws DatabaseException {
        Set result = new TreeSet();
        try {
            Connection conn = DatabaseManager.getInstance().getDatabaseConnection();
            Statement statement = conn.createStatement();
            String sqlString = "SELECT id FROM subscriptions " +
                    "WHERE user like '" + username + "';";
            ResultSet idList = statement.executeQuery(sqlString);
            while (idList.next()) {
                int id = idList.getInt("id");
                result.add(subscriptions.get(new Integer(id)));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        
        return result;
    }

    /**
     * @param string
     * @return
     */
    private Set getDontCareSubscriptions(String field) {
        Set result = new TreeSet();
        if (dontCareSubscriptions.containsKey(field)) {
            result = (Set) dontCareSubscriptions.get(field);
        }
        return result;
    }
    
}