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

/*
 * 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.util.*;

import javax.servlet.http.HttpSession;

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 subscriptions = new TreeMap();

    private ProfileStore() {
    }

    /**
     * @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) {
        Predicate documentIdPredicate = subscription.getPredicate("documentID");
        Predicate collectionIdPredicate = subscription.getPredicate("collectionID");
        Predicate hostIdPredicate = subscription.getPredicate("host");
        Predicate typePredicate = subscription.getPredicate("type");
        
        Integer subId = new Integer(subscription.getId());
        
        if (documentIdPredicate == null && collectionIdPredicate == null 
                && hostIdPredicate == null && typePredicate == null) {
            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
        result.addAll(PredicateFactory.getIdEqualsPredicate("type", (String)event.get("type")).getSubscriptionIDs());
        
        Set docIDSubs = new TreeSet();
        docIDSubs.addAll(PredicateFactory.getIdEqualsPredicate("documentID", (String)event.get("documentID")).getSubscriptionIDs());
        docIDSubs.addAll(PredicateFactory.getIdEqualsPredicate("documentID", null).getSubscriptionIDs());
        result.retainAll(docIDSubs);
        
        Set collIDSubs = new TreeSet();
        collIDSubs.addAll(PredicateFactory.getIdEqualsPredicate("collectionID", (String)event.get("collectionID")).getSubscriptionIDs());
        collIDSubs.addAll(PredicateFactory.getIdEqualsPredicate("collectionID", null).getSubscriptionIDs());
        result.retainAll(collIDSubs);
        
        Set hostIDSubs = new TreeSet();
        hostIDSubs.addAll(PredicateFactory.getIdEqualsPredicate("host", (String)event.get("host")).getSubscriptionIDs());
        hostIDSubs.addAll(PredicateFactory.getIdEqualsPredicate("host", null).getSubscriptionIDs());
        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();) {
                // TODO change to subscription IDs
                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) {
        // 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
     */
    public Set getAllSubscriptionsFor(String username) {
        Set result = new TreeSet();
        // TODO get subscriptions from database
        return result;
    }
    
}