DbGlossary.java

/**********************************************************************************
* $URL: https://source.sakaiproject.org/svn/osp/trunk/glossary/api-impl/src/java/org/theospi/portfolio/help/model/DbGlossary.java $
* $Id: DbGlossary.java 105079 2012-02-24 23:08:11Z ottenhoff@longsight.com $
***********************************************************************************
*
 * Copyright (c) 2005, 2006, 2007, 2008 The Sakai Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ECL-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.theospi.portfolio.help.model;

import java.util.*;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.sakaiproject.event.api.Event;
import org.sakaiproject.event.cover.EventTrackingService;
import org.sakaiproject.metaobj.shared.mgt.IdManager;
import org.sakaiproject.metaobj.shared.model.Id;
import org.sakaiproject.api.app.scheduler.SchedulerManager;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.quartz.JobDetail;
import org.quartz.SimpleTrigger;
import org.quartz.SchedulerException;
import org.quartz.Trigger;

public class DbGlossary  extends HibernateDaoSupport implements Glossary, Observer {
   protected final transient Log logger = LogFactory.getLog(getClass());
   private Map worksiteGlossary = new Hashtable();
   private IdManager idManager;
   private List dirtyAddUpdate = new ArrayList();
   private List dirtyRemove = new ArrayList();
   private SchedulerManager schedulerManager;
   private int cacheInterval = 1000 * 10;
   private boolean useCache = true;

   private String url;

   private static final String EVENT_UPDATE_ADD = "org.theospi.glossary.updateAdd";
   private static final String EVENT_DELETE = "org.theospi.glossary.delete";

   public GlossaryEntry load(Id id) {
      GlossaryEntry entry = load(id, true);
      getHibernateTemplate().evict(entry);
      return entry;
   }

   protected GlossaryEntry load(Id id, boolean deep) {
      try {
         GlossaryEntry entry = (GlossaryEntry)getSession().load(GlossaryEntry.class, id);
         if (deep) {
            entry.setLongDescriptionObject(loadDescription(id));
         }
         return entry;
      } catch (HibernateException e) {
         logger.warn("", e);
         return null;
      }
   }

   protected GlossaryEntry find(Id id) {
      List entries = getHibernateTemplate().find("from GlossaryEntry where id = ?", id);
      if (entries.size() > 0) {
         return (GlossaryEntry)entries.get(0);
      }
      return null;
   }

   protected GlossaryDescription loadDescription(Id entryId) {
      Collection entries = getHibernateTemplate().findByNamedQuery("loadDescription",
         entryId);

      if (entries.size() > 0) {
         return (GlossaryDescription)entries.iterator().next();
      }
      else {
         return new GlossaryDescription();
      }
   }

   /**
    * find the keyword in the glossary.
    * return null if not found.
    *
    * @param keyword
    * @return
    */
   public GlossaryEntry find(String keyword, String worksite) {
      Collection entries = getHibernateTemplate().findByNamedQuery("findTerms", new Object[]{keyword, worksite});
      if (entries.size() == 0) {
         return null;
      }
      else if (entries.size() == 1) {
         return (GlossaryEntry)entries.iterator().next();
      }
      else {
         for (Iterator i=entries.iterator();i.hasNext();) {
            GlossaryEntry entry = (GlossaryEntry)i.next();
            if (entry.getWorksiteId() != null) {
               return entry;
            }
         }
      }

      return (GlossaryEntry)entries.iterator().next();
   }

   /**
    * returns the list of all GlossaryEntries
    *
    * @return
    */

   public Collection findAll(String keyword, String worksite) {
      return getHibernateTemplate().findByNamedQuery("findTerms", new Object[]{keyword, worksite});
   }

   /**
    * returns the list of all GlossaryEntries
    *
    * @return
    */
   public Collection findAll(String worksite) {
      return getHibernateTemplate().findByNamedQuery("findAllSiteTerms",
         new Object[]{worksite});
   }

   public Collection findAll() {
      return getHibernateTemplate().findByNamedQuery("findAllTerms");
   }

   public Collection findAllGlobal() {
      return getHibernateTemplate().findByNamedQuery("findGlobalTerms");
   }

   public GlossaryEntry addEntry(GlossaryEntry newEntry) {
      getHibernateTemplate().save(newEntry);
      newEntry.getLongDescriptionObject().setEntryId(newEntry.getId());
      getHibernateTemplate().save(newEntry.getLongDescriptionObject());
      updateCache(newEntry, false);
      return newEntry;
   }

   public void removeEntry(GlossaryEntry entry) {
      getHibernateTemplate().delete(entry);
      GlossaryDescription desc = loadDescription(entry.getId());
      getHibernateTemplate().delete(desc);
      updateCache(entry, true);
   }

   public void updateEntry(GlossaryEntry entry) {
      getHibernateTemplate().merge(entry);
      GlossaryDescription desc = loadDescription(entry.getId());
      desc.setLongDescription(entry.getLongDescription());
      getHibernateTemplate().merge(desc);
      updateCache(entry, false);
   }

   protected void updateCache(GlossaryEntry entry, boolean remove) {
      if (useCache) {
         GlossaryTxSync txSync = new GlossaryTxSync(entry, remove);

         if (TransactionSynchronizationManager.isSynchronizationActive()) {
            TransactionSynchronizationManager.registerSynchronization(txSync);
         }
         else {
            txSync.afterCompletion(GlossaryTxSync.STATUS_COMMITTED);
         }
      }
   }

   public Set getSortedWorksiteTerms(String worksiteId) {
      Set sortedSet = new TreeSet(new TermComparator());

      Map worksiteTerms = getWorksiteGlossary(worksiteId);
      if (worksiteTerms != null) {
         sortedSet.addAll(worksiteTerms.values());
      }

      String globalId = null;
      Map globalTerms = getWorksiteGlossary(globalId + "");

      if (globalTerms != null) {
         for (Iterator i=globalTerms.values().iterator();i.hasNext();) {
            GlossaryEntry entry = (GlossaryEntry)i.next();
            if (!sortedSet.contains(entry)) {
               sortedSet.add(entry);
            }
         }
      }

      return sortedSet;
   }

   protected Map getWorksiteGlossary(String worksiteId) {
      return getWorksiteGlossary(worksiteId, true);
   }
   
   protected Map getWorksiteGlossary(String worksiteId, boolean checkCache) {
      if (!useCache) {
         logger.warn("using glossary without cache, this could slow down osp tool page loads");
         Map terms = new Hashtable();
         Collection<GlossaryEntry> entries;
         if (worksiteId.equals(null + "")) {
            entries = findAllGlobal();
         }
         else {
            entries = findAll(worksiteId);
         }
         for (Iterator<GlossaryEntry> i = entries.iterator();i.hasNext();) {
            GlossaryEntry entry = i.next();
            terms.put(entry.getId(), entry);
         }
         return terms;
      }
      else {
         if (checkCache) {
            checkCache();
         }
         return (Map)worksiteGlossary.get(worksiteId);
      }
   }

   public void checkCache() {

      synchronized(dirtyAddUpdate) {
         for (Iterator<Id> i=dirtyAddUpdate.iterator();i.hasNext();) {
            GlossaryEntry entry = find(i.next());
            if (entry != null) {
               addUpdateTermCache(entry);
            }
         }
         dirtyAddUpdate.clear();
      }

      synchronized(dirtyRemove) {
         for (Iterator<Id> i=dirtyRemove.iterator();i.hasNext();) {
            removeCachedEntry(i.next());
         }
         dirtyRemove.clear();
      }

   }

   public boolean isPhraseStart(String phraseFragment, String worksite) {
      phraseFragment += "%";
      Collection entries = getHibernateTemplate().findByNamedQuery("findByPhrase", new Object[]{phraseFragment, worksite});
      if (entries.size() > 0) {
         return true;
      }

      return false;
   }

   public String getUrl() {
      return url;
   }

   public void setUrl(String url) {
      this.url = url;
   }

   public void importResources(String fromContext, String toContext, List resourceIds) {
      Collection orig = findAll(fromContext);

      for (Iterator i=orig.iterator();i.hasNext();) {
         GlossaryEntry entry = (GlossaryEntry)i.next();

         entry.setLongDescriptionObject(loadDescription(entry.getId()));

         getHibernateTemplate().evict(entry);
         getHibernateTemplate().evict(entry.getLongDescriptionObject());

         entry.setWorksiteId(toContext);
         entry.setId(null);
         getHibernateTemplate().save(entry);

         entry.getLongDescriptionObject().setEntryId(entry.getId());
         entry.getLongDescriptionObject().setId(null);
         getHibernateTemplate().save(entry.getLongDescriptionObject());
         addUpdateTermCache(entry);
      }
   }

   public void init() {
      if (isUseCache()) {
         logger.info("init()");
         Collection terms = findAll();

         for (Iterator i=terms.iterator();i.hasNext();) {
            GlossaryEntry entry = (GlossaryEntry)i.next();
            addUpdateTermCache(entry);
         }

         EventTrackingService.addObserver(this);

      }
   }

   protected void addUpdateTermCache(GlossaryEntry entry) {
      String worksiteId = entry.getWorksiteId() + "";
      Map worksiteMap = getWorksiteGlossary(worksiteId, false);

      if (worksiteMap == null) {
         worksiteGlossary.put(worksiteId, new Hashtable());
         worksiteMap = getWorksiteGlossary(worksiteId, false);
      }
      worksiteMap.put(entry.getId(), entry);
   }

   protected void removeCachedEntry(Id entryId) {
      for (Iterator i=worksiteGlossary.values().iterator();i.hasNext();) {
         Map map = (Map)i.next();
         if (map.remove(entryId) != null) {
            // found it
            return;
         }
      }
   }

   /**
    * This method is called whenever the observed object is changed. An
    * application calls an <tt>Observable</tt> object's
    * <code>notifyObservers</code> method to have all the object's
    * observers notified of the change.
    * 
    * This operates within its own Thread so normal rules and conditions don't apply
    *
    * @param o   the observable object.
    * @param arg an argument passed to the <code>notifyObservers</code>
    *            method.
    */
   public void update(Observable o, Object arg) {
      if (arg instanceof Event) {
         Event event = (Event)arg;
         if (event.getEvent().equals(EVENT_UPDATE_ADD)) {
            synchronized(dirtyAddUpdate) {
               dirtyAddUpdate.add(getIdManager().getId(event.getResource()));
            }
         }
         else if (event.getEvent().equals(EVENT_DELETE)) {
            synchronized(dirtyRemove) {
               dirtyRemove.add(getIdManager().getId(event.getResource()));
            }
         }
      }
   }

   public IdManager getIdManager() {
      return idManager;
   }

   public void setIdManager(IdManager idManager) {
      this.idManager = idManager;
   }

   private class GlossaryTxSync extends TransactionSynchronizationAdapter {
      private GlossaryEntry entry;
      private boolean remove = false;

      public GlossaryTxSync(GlossaryEntry entry, boolean remove) {
         this.entry = entry;
         this.remove = remove;
      }

      public void afterCompletion(int status) {
         Event event = null;
         if (status == STATUS_COMMITTED && remove) {
            event = EventTrackingService.newEvent(EVENT_DELETE, entry.getId().getValue(), false);
         }
         else if (status == STATUS_COMMITTED) {
            event = EventTrackingService.newEvent(EVENT_UPDATE_ADD, entry.getId().getValue(), false);
         }

         if (event != null) {
            EventTrackingService.post(event);
         }
      }

      public GlossaryEntry getEntry() {
         return entry;
      }

      public void setEntry(GlossaryEntry entry) {
         this.entry = entry;
      }
   }

   public SchedulerManager getSchedulerManager() {
      return schedulerManager;
   }

   public void setSchedulerManager(SchedulerManager schedulerManager) {
      this.schedulerManager = schedulerManager;
   }

   public int getCacheInterval() {
      return cacheInterval;
   }

   public void setCacheInterval(int cacheInterval) {
      this.cacheInterval = cacheInterval;
   }

   public boolean isUseCache() {
      return useCache;
   }

   public void setUseCache(boolean useCache) {
      this.useCache = useCache;
   }
}