0001: /*
0002: * LIUS - Lucene Index Update and Search
0003: * http://sourceforge.net/projects/lius/
0004: *
0005: * Copyright (c) 2005, Laval University Library. All rights reserved.
0006: *
0007: * This library is free software; you can redistribute it and/or
0008: * modify it under the terms of the GNU Lesser General Public
0009: * License as published by the Free Software Foundation; either
0010: * version 2.1 of the License, or (at your option) any later version.
0011: *
0012: * This library is distributed in the hope that it will be useful,
0013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0015: * Lesser General Public License for more details.
0016: *
0017: * You should have received a copy of the GNU Lesser General Public
0018: * License along with this library; if not, write to the Free Software
0019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
0020: *
0021: * Changelog:
0022: * $Log: LuceneActions.java,v $
0023: * Revision 1.3 2005/09/12 19:22:01 benjellr
0024: * + Add score to search results List
0025: * + Add UTF8AccentRemoverAnalyzer
0026: * + Add methode in luceneAction to liste all the documents in the index
0027: *
0028: * Revision 1.2 2005/06/18 09:22:42 jfendler
0029: * Fixed a bug in index(). Writer properties are now set _before_ indexing takes place.
0030: *
0031: */
0032:
0033: package ca.ulaval.bibl.lius.Lucene;
0034:
0035: import java.io.File;
0036: import java.io.IOException;
0037: import java.text.DateFormat;
0038: import java.text.ParseException;
0039: import java.text.SimpleDateFormat;
0040: import java.util.ArrayList;
0041: import java.util.Collection;
0042: import java.util.Iterator;
0043: import java.util.List;
0044:
0045: import org.apache.log4j.Logger;
0046: import org.apache.lucene.analysis.Analyzer;
0047: import org.apache.lucene.document.DateField;
0048: import org.apache.lucene.document.Document;
0049: import org.apache.lucene.document.Field;
0050: import org.apache.lucene.index.IndexReader;
0051: import org.apache.lucene.index.IndexWriter;
0052: import org.apache.lucene.index.Term;
0053: import org.apache.lucene.store.Directory;
0054: import org.apache.lucene.store.FSDirectory;
0055:
0056: import ca.ulaval.bibl.lius.Exception.LiusException;
0057: import ca.ulaval.bibl.lius.config.LiusConfig;
0058: import ca.ulaval.bibl.lius.config.LiusConfigBuilder;
0059: import ca.ulaval.bibl.lius.config.LiusDocumentProperty;
0060: import ca.ulaval.bibl.lius.config.LiusField;
0061: import ca.ulaval.bibl.lius.index.Indexer;
0062: import ca.ulaval.bibl.lius.index.IndexerFactory;
0063: import ca.ulaval.bibl.lius.index.JavaObject.BeanIndexer;
0064: import ca.ulaval.bibl.lius.index.MixteIndexing.MixteIndexer;
0065: import ca.ulaval.bibl.lius.index.XML.XmlNodeIndexer;
0066:
0067: /**
0068: *
0069: * Classe permettant d'effectuer des actions relatives à Lucene.
0070: *
0071: * <br/><br/>
0072: *
0073: * Class that executes actions related to Lucene.
0074: *
0075: * @author Rida Benjelloun (rida.benjelloun@bibl.ulaval.ca)
0076: *
0077: */
0078:
0079: public class LuceneActions {
0080:
0081: private static LuceneActions luceneActIns;
0082:
0083: static Logger logger = Logger.getRootLogger();
0084:
0085: private LuceneActions() {
0086: }
0087:
0088: public static LuceneActions getSingletonInstance() {
0089:
0090: if (luceneActIns == null)
0091:
0092: luceneActIns = new LuceneActions();
0093:
0094: return luceneActIns;
0095:
0096: }
0097:
0098: /**
0099: *
0100: * Methode permettant de construire un objet de type "Lucene Document"
0101: *
0102: * à partir de plusieurs collections contenant des informations sur
0103: *
0104: * les documents à indexer. Cette méthode est utilisée pour l'indexation
0105: * mixte.
0106: *
0107: * <br/><br/>
0108: *
0109: * Method that constructs a Lucene document object from many collections
0110: *
0111: * containing information on the documents to index. This method is used for
0112: * mixed
0113: *
0114: * indexation.
0115: *
0116: */
0117:
0118: public Document populateLuceneDocumentFromListOfCollectionFields(
0119: List
0120:
0121: listCollectionsFieldsContentAndType) {
0122:
0123: Collection coll = new ArrayList();
0124:
0125: for (int i = 0; i < listCollectionsFieldsContentAndType.size(); i++) {
0126:
0127: Collection collList = (Collection) listCollectionsFieldsContentAndType
0128: .
0129:
0130: get(i);
0131:
0132: Iterator it = collList.iterator();
0133:
0134: while (it.hasNext()) {
0135:
0136: LiusField lf = (LiusField) it.next();
0137:
0138: coll.add(lf);
0139:
0140: }
0141:
0142: }
0143:
0144: Document doc = populateLuceneDoc(coll);
0145:
0146: return doc;
0147:
0148: }
0149:
0150: public Document populateLuceneDoc(Collection fieldsContentAndType) {
0151:
0152: Document doc = new Document();
0153:
0154: LiusDocumentProperty ldp = null;
0155:
0156: logger.info("==== Nouveau lucene document dans l'index ====");
0157:
0158: Iterator it = fieldsContentAndType.iterator();
0159:
0160: while (it.hasNext()) {
0161:
0162: Field field = null;
0163:
0164: Object fieldColl = it.next();
0165:
0166: if (fieldColl instanceof LiusField) {
0167:
0168: LiusField lf = (LiusField) fieldColl;
0169:
0170: if (lf.getType().equals("Text")) {
0171:
0172: field = Field.Text(lf.getName(), lf.getValue());
0173:
0174: logger.info(lf.getName() + " (type = "
0175: + lf.getType() + ") " +
0176:
0177: " : " + lf.getValue());
0178:
0179: }
0180:
0181: else if (lf.getType().equals("TextReader")) {
0182:
0183: if (lf.getValueInputStreamReader() != null) {
0184:
0185: field = Field.Text(lf.getName(), lf
0186: .getValueInputStreamReader());
0187:
0188: }
0189:
0190: else if (lf.getValueReader() != null)
0191:
0192: field = Field.Text(lf.getName(), lf
0193: .getValueReader());
0194:
0195: logger.info(lf.getName() + " (type = "
0196: + lf.getType() + ") " +
0197:
0198: " : Texte ajouté");
0199:
0200: }
0201:
0202: else if (lf.getType().equals("Keyword")) {
0203:
0204: field = Field.Keyword(lf.getName(), lf.getValue());
0205:
0206: logger.info(lf.getName() + " (type = "
0207: + lf.getType() + ") " +
0208:
0209: " : " + lf.getValue());
0210:
0211: }
0212:
0213: /*
0214: * else if (lf.getType().equals("KeywordDateToString")) {
0215: *
0216: * doc.add(Field.Keyword(lf.getName(),
0217: * DateField.dateToString(lf.getDate())));
0218: *
0219: * System.out.println(lf.getName() + " (type = " + lf.getType() + ") " + " : " +
0220: * lf.getDate()); }
0221: */
0222:
0223: else if (lf.getType().equals("ADate")) {
0224:
0225: // try{
0226:
0227: //doc.add(Field.Keyword(lf.getName(),
0228: // DateField.dateToString(lf.getDate())));
0229:
0230: field = Field.Keyword(lf.getName(),
0231:
0232: (lf.getValue()).replaceAll("/", ""));
0233:
0234: logger.info(lf.getName() + " (type = "
0235: + lf.getType() + ") " +
0236:
0237: " : " + lf.getValue().replaceAll("/", ""));
0238:
0239: /*
0240: * }
0241: *
0242: * catch(java.text.ParseException e){
0243: *
0244: * e.printStackTrace(); }
0245: */
0246:
0247: }
0248:
0249: else if (lf.getType().equals("DateToString")) {
0250:
0251: field = Field.Keyword(lf.getName(),
0252:
0253: DateField.dateToString(lf.getDate()));
0254:
0255: logger.info(lf.getName() + " (type = "
0256: + lf.getType() + ") " +
0257:
0258: " : " + lf.getDate().toString());
0259:
0260: }
0261:
0262: else if (lf.getType().equals("StringToDate")) {
0263:
0264: DateFormat formatter = new SimpleDateFormat(lf
0265: .getDateFormat());
0266:
0267: try {
0268:
0269: field = Field.Keyword(lf.getName(),
0270:
0271: DateField.dateToString(
0272:
0273: formatter.parse(lf.getValue())));
0274:
0275: logger.info(lf.getName() + " (type = "
0276: + lf.getType() +
0277:
0278: ") " +
0279:
0280: " : " + lf.getValue());
0281:
0282: }
0283:
0284: catch (ParseException ex) {
0285:
0286: logger.error(ex.getMessage());
0287:
0288: }
0289:
0290: }
0291:
0292: else if (lf.getType().equals("UnIndexed")) {
0293:
0294: field = Field
0295: .UnIndexed(lf.getName(), lf.getValue());
0296:
0297: logger.info(lf.getName() + " (type = "
0298: + lf.getType() + ") " +
0299:
0300: " : " + lf.getValue());
0301:
0302: }
0303:
0304: else if (lf.getType().equals("UnStored")) {
0305:
0306: field = Field.UnStored(lf.getName(), lf.getValue());
0307:
0308: logger.info(lf.getName() + " (type = "
0309: + lf.getType() + ") " +
0310:
0311: " : " + lf.getValue());
0312:
0313: }
0314:
0315: if (lf.getIsBoosted() && field != null) {
0316:
0317: field.setBoost(lf.getBoost());
0318:
0319: logger.info("--------> Field " + lf.getName() +
0320:
0321: " setBoost = " + lf.getBoost());
0322:
0323: }
0324:
0325: if (field != null) {
0326:
0327: doc.add(field);
0328:
0329: }
0330:
0331: }
0332:
0333: else if (fieldColl instanceof LiusDocumentProperty) {
0334:
0335: ldp = (LiusDocumentProperty) fieldColl;
0336:
0337: }
0338:
0339: }
0340:
0341: if (ldp != null && ldp.getBoost() != null) {
0342:
0343: doc.setBoost(Float.parseFloat(ldp.getBoost()));
0344:
0345: logger.info("@@@@@@@@@@@@@@@ Document boost = "
0346: + ldp.getBoost() +
0347:
0348: " @@@@@@@@@@@@@@@");
0349:
0350: }
0351:
0352: return doc;
0353:
0354: }
0355:
0356: /**
0357: *
0358: * Méthode permettant d'insérer une liste de documents Lucene dans l'index.
0359: *
0360: * <br/><br/>
0361: *
0362: * Method that inserts a list of Lucene documents in the index.
0363: *
0364: */
0365:
0366: public synchronized void save(List luceneDocs, IndexWriter writer,
0367:
0368: LiusConfig lc) throws
0369:
0370: LiusException {
0371:
0372: for (int i = 0; i < luceneDocs.size(); i++)
0373:
0374: save((Document) luceneDocs.get(i), writer, lc);
0375:
0376: }
0377:
0378: /**
0379: *
0380: * Méthode permettant d'insérer un document Lucene dans l'index
0381: *
0382: * <br/><br/>
0383: *
0384: * Méthod that inserts a Lucene document in the index.
0385: *
0386: */
0387:
0388: public synchronized void save(Document luceneDoc,
0389: IndexWriter writer,
0390:
0391: LiusConfig lc) throws
0392:
0393: LiusException {
0394:
0395: try {
0396:
0397: writer.addDocument(luceneDoc);
0398:
0399: logger
0400: .info("**************Document Ajouté à l'index*********");
0401:
0402: }
0403:
0404: catch (IOException e) {
0405:
0406: logger.error(e.getMessage());
0407:
0408: logger
0409: .error("*************Document non Ajouté à l'index*********");
0410:
0411: }
0412:
0413: if (lc.getOptimizeValue() != null) {
0414:
0415: if (lc.getOptimize()) {
0416:
0417: try {
0418:
0419: writer.optimize();
0420:
0421: }
0422:
0423: catch (IOException e) {
0424:
0425: logger.error(e.getMessage());
0426:
0427: }
0428:
0429: }
0430:
0431: }
0432:
0433: }
0434:
0435: /**
0436: *
0437: * Méthode utilisée pour lancer le processus d'indexation.
0438: *
0439: * Elle prépare le processus d'indexation pour la méthode
0440: * fileDirectoryIndexing(),
0441: *
0442: * en parsant le fichier de configuration, en initialisant les propriétés de
0443: *
0444: * l'index et en créant l'analyseur.
0445: *
0446: * Elle prend comme paramètres le fichier ou le répertoire à indexer,
0447: *
0448: * le répertoire d'enregistrement de l'index et le fichier XML de
0449: * configuration.
0450: *
0451: * <br/><br/>
0452: *
0453: * Method that begins the indexation process. It prepares the indexation
0454: * process
0455: *
0456: * with the method fileDirectoryIndexing(), by parsing the configuration
0457: * file, by
0458: *
0459: * initializing the index properties and by creating the analyser.
0460: *
0461: * It takes as parameters the file or directory to index, the directory to
0462: * save
0463: *
0464: * the index and the XML configuration file.
0465: *
0466: */
0467:
0468: public synchronized void index(String toIndex,
0469:
0470: String indexDir,
0471:
0472: String liusConfig) throws LiusException,
0473:
0474: IOException {
0475:
0476: LiusConfig lc = LiusConfigBuilder.getSingletonInstance().
0477:
0478: getLiusConfig(liusConfig);
0479:
0480: Analyzer analyzer = AnalyzerFactory.getAnalyzer(lc);
0481:
0482: IndexWriter writer = null;
0483:
0484: try {
0485:
0486: boolean createIndex = createIndexValue(lc.getCreateIndex(),
0487: indexDir);
0488:
0489: Directory fsDir = FSDirectory.getDirectory(indexDir,
0490: createIndex);
0491:
0492: writer = new IndexWriter(fsDir, analyzer,
0493:
0494: createIndex);
0495:
0496: setIndexWriterProps(writer, lc);
0497:
0498: fileDirectoryIndexing(toIndex, lc, writer);
0499:
0500: }
0501:
0502: catch (Exception e) {
0503:
0504: // writer.close();
0505:
0506: logger.error(e.getMessage());
0507:
0508: }
0509:
0510: finally {
0511:
0512: unLock(indexDir);
0513:
0514: writer.close();
0515:
0516: }
0517:
0518: }
0519:
0520: /**
0521: *
0522: * Méthode permettant de forcer l'ouverture de l'index de Lucene quand il
0523: * est fermé.
0524: *
0525: * <br/><br/>
0526: *
0527: * Method that force the opening of Lucene index when it is closed.
0528: *
0529: */
0530:
0531: public void unLock(String indexDir) {
0532:
0533: try {
0534:
0535: Directory directory = FSDirectory.getDirectory(indexDir,
0536: false);
0537:
0538: IndexReader.open(directory);
0539:
0540: if (IndexReader.isLocked(directory)) {
0541:
0542: IndexReader.unlock(directory);
0543:
0544: }
0545:
0546: }
0547:
0548: catch (IOException e) {
0549:
0550: logger.error(e.getMessage());
0551:
0552: }
0553:
0554: }
0555:
0556: public synchronized void deleteAllDocuments(String indexDir) {
0557:
0558: try {
0559:
0560: Directory directory = FSDirectory.getDirectory(indexDir,
0561: false);
0562:
0563: IndexReader ir = IndexReader.open(directory);
0564:
0565: int num = ir.numDocs();
0566:
0567: for (int i = 0; i <= num - 1; i++) {
0568:
0569: ir.delete(i);
0570:
0571: }
0572:
0573: ir.close();
0574:
0575: }
0576:
0577: catch (IOException e) {
0578:
0579: logger.error(e.getMessage());
0580:
0581: }
0582:
0583: }
0584:
0585: public synchronized List ListAllDocuments(String indexDir) {
0586: List documentsList = new ArrayList();
0587: try {
0588: Directory directory = FSDirectory.getDirectory(indexDir,
0589: false);
0590: IndexReader ir = IndexReader.open(directory);
0591: int num = ir.numDocs();
0592: for (int i = 0; i <= num - 1; i++) {
0593: documentsList.add(ir.document(i));
0594: }
0595: ir.close();
0596: } catch (IOException e) {
0597: logger.error(e.getMessage());
0598: }
0599: return documentsList;
0600: }
0601:
0602: public synchronized void unDeleteAllDocuments(String indexDir) {
0603:
0604: try {
0605:
0606: Directory directory = FSDirectory.getDirectory(indexDir,
0607: false);
0608:
0609: IndexReader ir = IndexReader.open(directory);
0610:
0611: ir.undeleteAll();
0612:
0613: ir.close();
0614:
0615: }
0616:
0617: catch (IOException e) {
0618:
0619: logger.error(e.getMessage());
0620:
0621: }
0622:
0623: }
0624:
0625: public synchronized void newIndex(String indexDir) {
0626:
0627: try {
0628:
0629: Directory directory = FSDirectory.getDirectory(indexDir,
0630: true);
0631:
0632: }
0633:
0634: catch (IOException ex) {
0635:
0636: logger.error(ex.getMessage());
0637:
0638: }
0639:
0640: }
0641:
0642: /**
0643: *
0644: * Méthode permettant d'initialiser les propriétés de l'index si ces
0645: * dernières ont
0646: *
0647: * été placées dans le fichier de configuration.
0648: *
0649: * <br/><br/>
0650: *
0651: * Method that initializes the properties of the index if those were placed
0652: * in the
0653: *
0654: * configuration file.
0655: *
0656: */
0657:
0658: public void setIndexWriterProps(IndexWriter writer, LiusConfig lc) {
0659:
0660: if (lc.getMergeFactor() != null)
0661:
0662: writer.mergeFactor = (new Integer(lc.getMergeFactor()))
0663: .intValue();
0664:
0665: if (lc.getMaxMergeDocs() != null)
0666:
0667: writer.maxMergeDocs = (new Integer(lc.getMaxMergeDocs()))
0668: .intValue();
0669:
0670: }
0671:
0672: /**
0673: *
0674: * Méthode appelée par la méthode index(). Elle permet d'effectuer le
0675: * processus
0676: *
0677: * d'indexation.
0678: *
0679: * <br/><br/>
0680: *
0681: * Method called by index(). It processes the indexation.
0682: *
0683: */
0684:
0685: private void fileDirectoryIndexing(String toIndex,
0686:
0687: LiusConfig lc,
0688:
0689: IndexWriter writer) throws IOException {
0690:
0691: String sep = System.getProperty("file.separator");
0692:
0693: File typFD = new File(toIndex);
0694:
0695: if (typFD.isFile()) {
0696:
0697: fileProcessing(toIndex, lc, writer);
0698:
0699: }
0700:
0701: else if (typFD.isDirectory()) {
0702:
0703: File[] liste = (new File(toIndex)).listFiles();
0704:
0705: if (lc.getMixteIndexingElements().size() > 0) {
0706:
0707: Indexer mi = new MixteIndexer();
0708:
0709: Document doc = mi.createLuceneDocument(toIndex, lc);
0710:
0711: try {
0712:
0713: save(doc, writer, lc);
0714:
0715: }
0716:
0717: catch (LiusException e) {
0718:
0719: // writer.close();
0720:
0721: logger.error(e.getMessage());
0722:
0723: }
0724:
0725: }
0726:
0727: else {
0728:
0729: for (int i = 0; i < liste.length; i++) {
0730:
0731: String fileToIndexB = toIndex + sep
0732: + liste[i].getName();
0733:
0734: fileProcessing(fileToIndexB, lc, writer);
0735:
0736: }
0737:
0738: }
0739:
0740: }
0741:
0742: }
0743:
0744: /**
0745: *
0746: * Méthode permettant d'indexer des Java Beans. Elle prend comme argument
0747: * une
0748: *
0749: * liste d'objets, le chemin de l'index et le fichier de configuration.
0750: *
0751: * <br/><br/>
0752: *
0753: * Method that indexes JavaBeans. It takes as parameters a list of objects,
0754: * the path
0755: *
0756: * of the index and the configuration file.
0757: *
0758: */
0759:
0760: public synchronized void indexJavaBeans(List beans,
0761: String indexDir,
0762:
0763: String fichierXMLConfig) throws
0764:
0765: IOException {
0766:
0767: LiusConfig lc = LiusConfigBuilder.getSingletonInstance().
0768:
0769: getLiusConfig(fichierXMLConfig);
0770:
0771: Analyzer analyzer = AnalyzerFactory.getAnalyzer(lc);
0772:
0773: IndexWriter writer = null;
0774:
0775: try {
0776:
0777: boolean createIndex = createIndexValue(lc.getCreateIndex(),
0778: indexDir);
0779:
0780: Directory fsDir = FSDirectory.getDirectory(indexDir,
0781: createIndex);
0782:
0783: writer = new IndexWriter(fsDir, analyzer, createIndex);
0784:
0785: setIndexWriterProps(writer, lc);
0786:
0787: for (int i = 0; i < beans.size(); i++) {
0788:
0789: BeanIndexer joi = new BeanIndexer();
0790:
0791: Document doc = joi.createLuceneDocument(beans.get(i),
0792: lc);
0793:
0794: save(doc, writer, lc);
0795:
0796: }
0797:
0798: }
0799:
0800: catch (Exception e) {
0801:
0802: logger.error(e.getMessage());
0803:
0804: }
0805:
0806: finally {
0807:
0808: writer.close();
0809: unLock(indexDir);
0810:
0811: }
0812:
0813: }
0814:
0815: /**
0816: *
0817: * Méthode permettant d'indexer un seul objet JavaBean.
0818: *
0819: * <br/>
0820: *
0821: * Method that indexes only one JavaBean.
0822: *
0823: */
0824:
0825: public synchronized void indexJavaBean(Object bean,
0826: String indexDir,
0827:
0828: String fichierXMLConfig) throws
0829:
0830: IOException {
0831:
0832: LiusConfig lc = LiusConfigBuilder.getSingletonInstance().
0833:
0834: getLiusConfig(fichierXMLConfig);
0835:
0836: Analyzer analyzer = AnalyzerFactory.getAnalyzer(lc);
0837:
0838: IndexWriter writer = null;
0839:
0840: try {
0841:
0842: boolean createIndex = createIndexValue(lc.getCreateIndex(),
0843: indexDir);
0844:
0845: Directory fsDir = FSDirectory.getDirectory(indexDir,
0846: createIndex);
0847:
0848: writer = new IndexWriter(fsDir, analyzer, createIndex);
0849:
0850: setIndexWriterProps(writer, lc);
0851:
0852: BeanIndexer joi = new BeanIndexer();
0853:
0854: Document doc = joi.createLuceneDocument(bean, lc);
0855:
0856: save(doc, writer, lc);
0857:
0858: }
0859:
0860: catch (Exception e) {
0861: logger.error(e.getMessage());
0862: }
0863:
0864: finally {
0865:
0866: writer.close();
0867: unLock(indexDir);
0868:
0869: }
0870:
0871: }
0872:
0873: /**
0874: *
0875: * Méthode appelée par la la méthode fileDirectoryIndexing(), pour indexer
0876: *
0877: * en fonction du type de fichier.
0878: *
0879: * <br/><br/>
0880: *
0881: * Method called by fileDirectoryIndexing(), for indexing related to the
0882: * file type.
0883: *
0884: */
0885:
0886: private void fileProcessing(String fileToIndex, LiusConfig lc,
0887:
0888: IndexWriter writer) {
0889:
0890: Indexer indexer = null;
0891:
0892: try {
0893:
0894: if (lc.getXmlNodesFields().size() > 0 &&
0895:
0896: fileToIndex.toLowerCase().endsWith(".xml")) {
0897:
0898: XmlNodeIndexer nodeIndexer = new XmlNodeIndexer();
0899:
0900: if (nodeIndexer != null) {
0901:
0902: List lucenedocsListe = nodeIndexer.
0903:
0904: createLuceneDocForEachNodeOfDocument(
0905:
0906: fileToIndex, lc.getXmlNodesFields());
0907:
0908: save(lucenedocsListe, writer, lc);
0909:
0910: }
0911:
0912: }
0913:
0914: else {
0915:
0916: indexer = IndexerFactory.getIndexer(fileToIndex, lc);
0917:
0918: if (indexer != null) {
0919:
0920: Document doc = indexer.createLuceneDocument(
0921: fileToIndex, lc);
0922:
0923: save(doc, writer, lc);
0924:
0925: }
0926:
0927: }
0928:
0929: }
0930:
0931: catch (LiusException e) {
0932: logger.error(e.getMessage());
0933: }
0934:
0935: }
0936:
0937: /**
0938: *
0939: * Méthode permettant d'effacer un document dans l'index. Elle prend comme
0940: *
0941: * arguments le répertoire de l'index, le nom du champs et le contenu
0942: * recherché.
0943: *
0944: * <br/><br/>
0945: *
0946: * Method that erases a document from the index. Its parameters are the
0947: * directory of
0948: *
0949: * the index, the name of the field and the content searched.
0950: *
0951: */
0952:
0953: public synchronized void deleteDoc(String indexDir, String field,
0954:
0955: String content) throws
0956:
0957: LiusException {
0958:
0959: try {
0960:
0961: Directory fsDir = FSDirectory.getDirectory(indexDir, false);
0962:
0963: IndexReader indexReader = IndexReader.open(fsDir);
0964:
0965: Term t = new Term(field, content);
0966:
0967: indexReader.delete(t);
0968:
0969: indexReader.close();
0970:
0971: logger.info("Document supprimé");
0972:
0973: }
0974:
0975: catch (IOException e) {
0976:
0977: logger.error(e.getMessage());
0978:
0979: }
0980:
0981: }
0982:
0983: /**
0984: *
0985: * Méthode permettant d'effacer un document dans l'index.
0986: *
0987: * Elle prend comme arguments le répertoire de l'index et un objet de type
0988: *
0989: * Lucene Term.
0990: *
0991: * <br/><br/>
0992: *
0993: * Method that erases a document from the index. Its parameters are the
0994: * directory
0995: *
0996: * of the index and a Lucene term object.
0997: *
0998: */
0999:
1000: public synchronized void deleteDoc(String indexDir, Term t) throws
1001:
1002: LiusException {
1003:
1004: try {
1005:
1006: Directory fsDir = FSDirectory.getDirectory(indexDir, false);
1007:
1008: IndexReader indexReader = IndexReader.open(fsDir);
1009:
1010: indexReader.delete(t);
1011:
1012: indexReader.close();
1013:
1014: logger.info("Document supprimé");
1015:
1016: }
1017:
1018: catch (IOException e) {
1019:
1020: logger.error(e.getMessage());
1021:
1022: }
1023:
1024: }
1025:
1026: /**
1027: *
1028: * Méthode permettant de mettre à jour un document dans l'index.
1029: *
1030: * Elle prend comme arguments le répertoire de l'index, un objet de type
1031: * lucene
1032: *
1033: * Term, le fichier à indexer à la place de celui trouvé et le fichier XML
1034: * de
1035: *
1036: * configuration qui servira à l'indexation.
1037: *
1038: * <br/><br/>
1039: *
1040: * Method that updated a document in the index. Its parameters are the
1041: * directory of
1042: *
1043: * the index, an Lucene Term object, the file to index in place of the one
1044: * found and
1045: *
1046: * the XML configuration file which will serve for indexing.
1047: *
1048: *
1049: *
1050: */
1051:
1052: public synchronized void updateDoc(String rep, Term t,
1053: String fileToReindex,
1054:
1055: String configFile) throws LiusException,
1056:
1057: IOException {
1058:
1059: deleteDoc(rep, t);
1060:
1061: getSingletonInstance().index(fileToReindex, rep, configFile);
1062:
1063: logger.info("Document mis à jour");
1064:
1065: }
1066:
1067: /**
1068: *
1069: * Méthode permettant de mettre à jour un document dans l'index. Elle prend
1070: *
1071: * comme arguments le repertoire de l'index, le nom du champs qui doit
1072: * contenir
1073: *
1074: * la valeur recherchée, le fichier à indexer à la place de
1075: *
1076: * celui trouvé et le fichier XML de configuration qui servira à la
1077: * réindexation.
1078: *
1079: * <br/><br/>
1080: *
1081: * Method that updates a document in the index. Its parameters are the
1082: * directory of
1083: *
1084: * the index, the name of the field which will contain the searched value,
1085: * the
1086: *
1087: * searched value, the file to index in place of the one found and the XML
1088: *
1089: * configuration which will serve for indexing.
1090: *
1091: */
1092:
1093: public synchronized void updateDoc(String rep, String field,
1094: String content,
1095:
1096: String fileToReindex, String configFile) throws
1097:
1098: LiusException, IOException {
1099:
1100: deleteDoc(rep, field, content);
1101:
1102: getSingletonInstance().index(fileToReindex, rep, configFile);
1103:
1104: logger.info("Document mis à jour");
1105:
1106: }
1107:
1108: public boolean createIndexValue(String valueCreateIndex,
1109: String indexDir) {
1110:
1111: boolean createIndex = false;
1112:
1113: String sep = File.separator;
1114:
1115: if (valueCreateIndex.equals("true"))
1116:
1117: createIndex = true;
1118:
1119: else if (valueCreateIndex.equals("false"))
1120:
1121: createIndex = false;
1122:
1123: else if (valueCreateIndex.equals("auto")) {
1124:
1125: createIndex = !indexExists(indexDir);
1126:
1127: }
1128:
1129: return createIndex;
1130:
1131: }
1132:
1133: /**
1134: *
1135: * Méthode permettant de vérifier le répertoire de sortie de l'index.
1136: *
1137: * S'il n'existe pas il sera crée.
1138: *
1139: * <br/><br/>
1140: *
1141: * Method for verifying the output directory of index. If it does not exist
1142: *
1143: * it will be created.
1144: *
1145: */
1146:
1147: public boolean indexExists(String indexDir) {
1148:
1149: return IndexReader.indexExists(indexDir);
1150:
1151: }
1152:
1153: }
|