addons/document/std_index.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 from content_index import indexer, cntIndex
  23 from subprocess import Popen, PIPE
  24 import StringIO
  25 import odt2txt
  26 import sys, zipfile, xml.dom.minidom
  27
  28 def _to_unicode(s):
  29     try:
  30         return s.decode('utf-8')
  31     except UnicodeError:
  32         try:
  33             return s.decode('latin')
  34         except UnicodeError:
  35             try:
  36                 return s.encode('ascii')
  37             except UnicodeError:
  38                 return s
  39
  40 def textToString(element) :
  41     buffer = u""
  42     for node in element.childNodes :
  43         if node.nodeType == xml.dom.Node.TEXT_NODE :
  44             buffer += node.nodeValue
  45         elif node.nodeType == xml.dom.Node.ELEMENT_NODE :
  46             buffer += textToString(node)
  47     return buffer
  48
  49 class TxtIndex(indexer):
  50     def _getMimeTypes(self):
  51         return ['text/plain','text/html','text/diff','text/xml', 'text/*',
  52             'application/xml']
  53
  54     def _getExtensions(self):
  55         return ['.txt', '.py']
  56
  57     def _doIndexContent(self,content):
  58         return content
  59
  60 cntIndex.register(TxtIndex())
  61
  62 class PptxIndex(indexer):
  63     def _getMimeTypes(self):
  64         return [ 'application/vnd.openxmlformats-officedocument.presentationml.presentation']
  65
  66     def _getExtensions(self):
  67         return ['.pptx']
  68
  69     def _doIndexFile(self,fname):
  70         def toString () :
  71             """ Converts the document to a string. """
  72             buffer = u""
  73             for val in ["a:t"]:
  74                 for paragraph in content.getElementsByTagName(val) :
  75                     buffer += textToString(paragraph) + "\n"
  76             return buffer
  77
  78         data = []
  79         zip = zipfile.ZipFile(fname)
  80         files = filter(lambda x: x.startswith('ppt/slides/slide'), zip.namelist())
  81         for i in range(1, len(files) + 1):
  82             content = xml.dom.minidom.parseString(zip.read('ppt/slides/slide%s.xml' % str(i)))
  83             res = toString().encode('ascii','replace')
  84             data.append(res)
  85
  86         return _to_unicode('\n'.join(data))
  87
  88 cntIndex.register(PptxIndex())
  89
  90 class DocIndex(indexer):
  91     def _getMimeTypes(self):
  92         return [ 'application/ms-word']
  93
  94     def _getExtensions(self):
  95         return ['.doc']
  96
  97     def _doIndexFile(self,fname):
  98         fp = Popen(['antiword', fname], shell=False, stdout=PIPE).stdout
  99         return _to_unicode(fp.read())
 100
 101 cntIndex.register(DocIndex())
 102
 103 class DocxIndex(indexer):
 104     def _getMimeTypes(self):
 105         return [ 'application/vnd.openxmlformats-officedocument.wordprocessingml.document']
 106
 107     def _getExtensions(self):
 108         return ['.docx']
 109
 110     def _doIndexFile(self,fname):
 111         zip = zipfile.ZipFile(fname)
 112         content = xml.dom.minidom.parseString(zip.read("word/document.xml"))
 113         def toString () :
 114             """ Converts the document to a string. """
 115             buffer = u""
 116             for val in ["w:p", "w:h", "text:list"]:
 117                 for paragraph in content.getElementsByTagName(val) :
 118                     buffer += textToString(paragraph) + "\n"
 119             return buffer
 120
 121         res = toString().encode('ascii','replace')
 122
 123         return _to_unicode(res)
 124
 125 cntIndex.register(DocxIndex())
 126
 127
 128 class XlsxIndex(indexer):
 129     def _getMimeTypes(self):
 130         return [ 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet']
 131
 132     def _getExtensions(self):
 133         return ['.xlsx']
 134
 135     def _doIndexFile(self,fname):
 136         zip = zipfile.ZipFile(fname)
 137         content = xml.dom.minidom.parseString(zip.read("xl/sharedStrings.xml"))
 138         def toString () :
 139             """ Converts the document to a string. """
 140             buffer = u""
 141             for val in ["t"]:
 142                 for paragraph in content.getElementsByTagName(val) :
 143                     buffer += textToString(paragraph) + "\n"
 144             return buffer
 145
 146         res = toString().encode('ascii','replace')
 147
 148         return _to_unicode(res)
 149
 150 cntIndex.register(XlsxIndex())
 151
 152 class PdfIndex(indexer):
 153     def _getMimeTypes(self):
 154         return [ 'application/pdf']
 155
 156     def _getExtensions(self):
 157         return ['.pdf']
 158
 159     def _doIndexFile(self,fname):
 160         fp = Popen(['pdftotext', '-enc', 'UTF-8', '-nopgbrk', fname, '-'], shell=False, stdout=PIPE).stdout
 161         return _to_unicode( fp.read())
 162
 163 cntIndex.register(PdfIndex())
 164
 165 class ImageNoIndex(indexer):
 166     def _getMimeTypes(self):
 167         return [ 'image/*']
 168
 169     def _getExtensions(self):
 170         #better return no extension, and let 'file' do its magic
 171         return []
 172         #return ['.png','.jpg','.gif','.jpeg','.bmp','.tiff']
 173
 174     def _doIndexContent(self,content):
 175         return 'image'
 176
 177
 178 cntIndex.register(ImageNoIndex())
 179
 180 # other opendocument formats:
 181 # chart-template chart database
 182 # formula-template formula graphics-template graphics
 183 # image
 184 # presentation-template presentation spreadsheet-template spreadsheet
 185
 186 class OpenDoc(indexer):
 187     """ Index OpenDocument files.
 188
 189         Q: is it really worth it to index spreadsheets, or do we only get a
 190         meaningless list of numbers (cell contents) ?
 191         """
 192     def _getMimeTypes(self):
 193         otypes = [ 'text', 'text-web', 'text-template', 'text-master' ]
 194         return map(lambda a: 'application/vnd.oasis.opendocument.'+a, otypes)
 195
 196     def _getExtensions(self):
 197         return ['.odt', '.ott', ] # '.ods'
 198
 199     def _doIndexContent(self, content):
 200         s = StringIO.StringIO(content)
 201         o = odt2txt.OpenDocumentTextFile(s)
 202         result = _to_unicode(o.toString())
 203         s.close()
 204         return result
 205
 206 cntIndex.register(OpenDoc())
 207
 208
 209 #eof