Workspace/Siman-Common/src/org/splat/service/technical/IndexServiceImpl.java

   1 package org.splat.service.technical;
   2 /**
   3  *
   4  * @author    Daniel Brunier-Coulin
   5  * @copyright OPEN CASCADE 2012
   6  */
   7
   8 import java.io.File;
   9 import java.io.IOException;
  10 import java.io.Serializable;
  11 import java.util.Iterator;
  12 import java.util.List;
  13 import java.util.Set;
  14
  15 import org.apache.log4j.Logger;
  16
  17 import org.apache.lucene.analysis.standard.StandardAnalyzer;
  18 import org.apache.lucene.document.Field;
  19 import org.apache.lucene.index.CorruptIndexException;
  20 import org.apache.lucene.index.IndexReader;
  21 import org.apache.lucene.index.IndexWriter;
  22 import org.apache.lucene.index.Term;
  23 import org.apache.lucene.store.Directory;
  24 import org.apache.lucene.store.FSDirectory;
  25 import org.apache.lucene.store.LockObtainFailedException;
  26 import org.apache.lucene.util.Version;
  27 import org.splat.dal.bo.kernel.User;
  28 import org.splat.dal.bo.som.KnowledgeElement;
  29 import org.splat.dal.bo.som.ProgressState;
  30 import org.splat.dal.bo.som.Scenario;
  31 import org.splat.dal.bo.som.SimulationContext;
  32 import org.splat.dal.bo.som.Study;
  33 import org.splat.dal.dao.som.Database;
  34 import org.splat.service.ProjectElementService;
  35 import org.splat.service.dto.Proxy;
  36 import org.splat.som.Step;
  37
  38
  39 public class IndexServiceImpl implements IndexService {
  40
  41     private Directory                            index;
  42     private org.apache.lucene.document.Document  body;
  43         private ProjectElementService _projectElementService;
  44         private RepositoryService     _repositoryService;
  45
  46         protected static       StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_29);
  47     private   static final Logger           logger   = Logger.getLogger(IndexServiceImpl.class);
  48
  49     private class Entry extends IndexWriter {
  50 //  ---------------------------------------
  51       private org.apache.lucene.document.Document entry;
  52
  53       private Entry (Study study) throws CorruptIndexException, LockObtainFailedException, IOException
  54       {
  55         super(index, analyzer, false, IndexWriter.MaxFieldLength.UNLIMITED);
  56
  57 //      Addition of mandatory fields
  58         entry = new org.apache.lucene.document.Document();
  59         Field  field;
  60         field = body.getField("index");
  61         field.setValue(String.valueOf(study.getIndex()));
  62         entry.add(field);
  63         field = body.getField("class");
  64         field.setValue("Study");
  65         entry.add(field);
  66         field = body.getField("type");
  67         field.setValue("");     // Reserved for configurable Study type
  68         entry.add(field);
  69         field = body.getField("ref");
  70         field.setValue(study.getReference());
  71         entry.add(field);
  72         field = body.getField("area");
  73         field.setValue(study.getVisibility().toString());
  74         entry.add(field);
  75         field = body.getField("state");
  76         field.setValue(study.getProgressState().toString());
  77         entry.add(field);
  78         field = body.getField("author");
  79         field.setValue(study.getAuthor().toString());
  80         entry.add(field);
  81         field = body.getField("title");
  82         field.setValue(study.getTitle());
  83         entry.add(field);
  84         field = body.getField("contents");
  85         field.setValue(study.getTitle());
  86         entry.add(field);
  87
  88 //      Addition of optional fields
  89         setActorsOf(study);
  90         setContextAt(getProjectElementService().getSteps(study));
  91       }
  92       private Entry (KnowledgeElement kelm) throws CorruptIndexException, LockObtainFailedException, IOException
  93       {
  94         super(index, analyzer, false, IndexWriter.MaxFieldLength.UNLIMITED);
  95
  96 //      Addition of mandatory fields
  97         entry = new org.apache.lucene.document.Document();
  98         Field field;
  99         field = body.getField("index");
 100         field.setValue(String.valueOf(kelm.getIndex()));
 101         entry.add(field);
 102         field = body.getField("class");
 103         field.setValue("KnowledgeElement");
 104         entry.add(field);
 105         field = body.getField("type");
 106         field.setValue(kelm.getType().getName());
 107         entry.add(field);
 108         field = body.getField("ref");
 109         field.setValue(kelm.getReference());
 110         entry.add(field);
 111         field = body.getField("area");
 112         field.setValue(kelm.getVisibility().toString());
 113         entry.add(field);
 114         field = body.getField("state");
 115         field.setValue(kelm.getProgressState().toString());
 116         entry.add(field);
 117         field = body.getField("author");
 118         field.setValue(kelm.getAuthor().toString());
 119         entry.add(field);
 120         field = body.getField("title");
 121         field.setValue(kelm.getTitle());
 122         entry.add(field);
 123         field = body.getField("contents");
 124         field.setValue(kelm.getTitle());
 125         entry.add(field);
 126
 127 //TODO: Addition of optional fields
 128         Scenario scene = kelm.getOwnerScenario();
 129         Study    study = scene.getOwnerStudy();
 130         setActorsOf(study);  // For restricting the visibility of knowledges attached to private studies
 131         setContextAt(getProjectElementService().getSteps(study));
 132         setContextAt(getProjectElementService().getSteps(scene));
 133       }
 134       private void add () throws CorruptIndexException, IOException
 135       {
 136         addDocument(entry);
 137 //      Save the new entry
 138         optimize();          // Should be called before committing the index
 139         close();             // Commits the index
 140       }
 141       private void update () throws CorruptIndexException, IOException
 142       {
 143         String value = entry.getField("ref").stringValue();   // Only field with unique value
 144         Term   term  = new Term("ref").createTerm(value);
 145         updateDocument(term, entry);
 146 //      Save the updated entry
 147         optimize();          // Should be called before committing the index
 148         close();             // Commits the index
 149       }
 150       private void setContextAt (Step[] step)
 151       {
 152         for (int i=0; i<step.length; i++) {
 153           List<SimulationContext> contexts = step[i].getAllSimulationContexts();
 154           for (Iterator<SimulationContext> j=contexts.iterator(); j.hasNext();) {
 155             SimulationContext  context = j.next();
 156             String             type    = String.valueOf(context.getType().getIndex());
 157             String             value   = context.getValue();
 158             entry.add( new Field(type, value, Field.Store.NO, Field.Index.NOT_ANALYZED) );
 159           }
 160         }
 161       }
 162       private void setActorsOf (Study study)
 163       {
 164         Set<User> actors = study.getActors();
 165         for (Iterator<User> i=actors.iterator(); i.hasNext(); ) {
 166           String value = i.next().toString();
 167           entry.add( new Field("actor", value, Field.Store.NO, Field.Index.NOT_ANALYZED) );
 168         }
 169       }
 170     }
 171     public static class ObjectProxy implements Proxy, Serializable {
 172 //  --------------------------------------------------------------
 173       private int           rid;
 174       private String        sid;
 175       private ProgressState state;
 176       private String        title;
 177       private String        type;
 178       private String        name;
 179       private static final long serialVersionUID = -4386494192709562221L;
 180
 181       public ObjectProxy (org.apache.lucene.document.Document ludoc) {
 182         rid   = Integer.valueOf(ludoc.get("index"));
 183         sid   = ludoc.get("ref");
 184         state = ProgressState.valueOf(ludoc.get("state"));
 185         title = ludoc.get("title");
 186         name  = ludoc.get("author");
 187       }
 188       public String getAuthorName () {
 189         return name;
 190       }
 191       public Integer getIndex () {
 192         return rid;
 193       }
 194       public ProgressState getProgressState () {
 195         return state;
 196       }
 197       public String getReference () {
 198         return sid;
 199       }
 200       public String getTitle () {
 201         return title;
 202       }
 203       public String getType () {
 204         return type;
 205       }
 206     }
 207
 208 //  ==============================================================================================================================
 209 //  Construction
 210 //  ==============================================================================================================================
 211
 212     public void configure () throws IOException {
 213         File indir = getRepositoryService().getRepositoryIndexDirectory();
 214         index = FSDirectory.open(indir);
 215         body  = new org.apache.lucene.document.Document();
 216         body.add( new Field("index",   "", Field.Store.YES, Field.Index.NOT_ANALYZED) );
 217         body.add( new Field("class",   "", Field.Store.NO,  Field.Index.NOT_ANALYZED) );
 218         body.add( new Field("type",    "", Field.Store.YES, Field.Index.NOT_ANALYZED) );
 219         body.add( new Field("ref",     "", Field.Store.YES, Field.Index.NOT_ANALYZED) );
 220         body.add( new Field("area",    "", Field.Store.NO,  Field.Index.NOT_ANALYZED) );
 221         body.add( new Field("state",   "", Field.Store.YES, Field.Index.NOT_ANALYZED) );
 222         body.add( new Field("author",  "", Field.Store.YES, Field.Index.NOT_ANALYZED) );
 223         body.add( new Field("title",   "", Field.Store.YES, Field.Index.NOT_ANALYZED) );
 224         body.add( new Field("contents","", Field.Store.NO,  Field.Index.ANALYZED) );
 225         if ( !this.exists() ) this.create();     // Happens when re-indexing all studies
 226     }
 227
 228     public void create () throws IOException {
 229 //  -------------------------------
 230       Directory   index  = FSDirectory.open(getRepositoryService().getRepositoryIndexDirectory());
 231           IndexWriter writer = new IndexWriter(index, analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED);
 232           writer.close();                                    // ====  Creates an empty index
 233     }
 234
 235 //  ==============================================================================================================================
 236 //  Member functions
 237 //  ==============================================================================================================================
 238
 239     public void add (Study study) throws IOException {
 240 //  --------------------------------
 241       IndexServiceImpl.Entry entry = new Entry(study);
 242       entry.add();
 243       if (logger.isInfoEnabled()) {
 244           logger.info("Study \"" + study.getIndex() + "\" indexed.");
 245       }
 246     }
 247
 248     public void add (KnowledgeElement kelm) throws IOException {
 249 //  ------------------------------------------
 250           IndexServiceImpl.Entry entry = new Entry(kelm);
 251       entry.add();
 252           if (logger.isInfoEnabled()) {
 253           logger.info("Knowledge \"" + kelm.getIndex() + "\" indexed.");
 254           }
 255     }
 256
 257     public boolean exists () {
 258 //  ---------------------------
 259       try {
 260                 return IndexReader.indexExists(index);
 261       }
 262       catch (IOException error) {
 263         error.printStackTrace();
 264         return false;
 265         }
 266     }
 267
 268     public void update (Study study) throws IOException {
 269 //  -----------------------------------
 270           IndexServiceImpl.Entry entry = new Entry(study);
 271           entry.update();
 272       if (logger.isInfoEnabled()) {
 273           logger.info("Study \"" + study.getIndex() + "\" re-indexed.");
 274       }
 275     }
 276
 277     public void update (KnowledgeElement kelm) throws IOException {
 278 //  ---------------------------------------------
 279           IndexServiceImpl.Entry entry = new Entry(kelm);
 280           entry.update();
 281       if (logger.isInfoEnabled()) {
 282           logger.info("Knowledge \"" + kelm.getIndex() + "\" re-indexed.");
 283       }
 284     }
 285         /**
 286          * Get the projectElementService.
 287          * @return the projectElementService
 288          */
 289         public ProjectElementService getProjectElementService() {
 290                 return _projectElementService;
 291         }
 292
 293         /**
 294          * Set the projectElementService.
 295          * @param projectElementService the projectElementService to set
 296          */
 297         public void setProjectElementService(ProjectElementService projectElementService) {
 298                 _projectElementService = projectElementService;
 299         }
 300
 301         /**
 302          * Get the repositoryService.
 303          * @return the repositoryService
 304          */
 305         public RepositoryService getRepositoryService() {
 306                 return _repositoryService;
 307         }
 308
 309         /**
 310          * Set the repositoryService.
 311          * @param repositoryService the repositoryService to set
 312          */
 313         public void setRepositoryService(RepositoryService repositoryService) {
 314                 _repositoryService = repositoryService;
 315         }
 316 }