source: trunk/email2trac.py.in @ 359

Last change on this file since 359 was 359, checked in by bas, 11 years ago

email2trac.py.in:

  • Property svn:executable set to *
  • Property svn:keywords set to Id
File size: 53.5 KB
Line 
1#!@PYTHON@
2# Copyright (C) 2002
3#
4# This file is part of the email2trac utils
5#
6# This program is free software; you can redistribute it and/or modify it
7# under the terms of the GNU General Public License as published by the
8# Free Software Foundation; either version 2, or (at your option) any
9# later version.
10#
11# This program is distributed in the hope that it will be useful,
12# but WITHOUT ANY WARRANTY; without even the implied warranty of
13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14# GNU General Public License for more details.
15#
16# You should have received a copy of the GNU General Public License
17# along with this program; if not, write to the Free Software
18# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
19#
20# For vi/emacs or other use tabstop=4 (vi: set ts=4)
21#
22"""
23email2trac.py -- Email tickets to Trac.
24
25A simple MTA filter to create Trac tickets from inbound emails.
26
27Copyright 2005, Daniel Lundin <daniel@edgewall.com>
28Copyright 2005, Edgewall Software
29
30Authors:
31  Bas van der Vlies <basv@sara.nl>
32  Walter de Jong <walter@sara.nl>
33
34The scripts reads emails from stdin and inserts directly into a Trac database.
35
36How to use
37----------
38 * See https://subtrac.sara.nl/oss/email2trac/
39
40 * Create an config file:
41    [DEFAULT]                        # REQUIRED
42    project      : /data/trac/test   # REQUIRED
43    debug        : 1                 # OPTIONAL, if set print some DEBUG info
44    trac_version : 0.10              # OPTIONAL, default is 0.11
45
46    [jouvin]                         # OPTIONAL project declaration, if set both fields necessary
47    project      : /data/trac/jouvin # use -p|--project jouvin. 
48       
49 * default config file is : /etc/email2trac.conf
50
51 * Commandline opions:
52                -h,--help
53                -f,--file  <configuration file>
54                -n,--dry-run
55                -p, --project <project name>
56                -t, --ticket_prefix <name>
57
58SVN Info:
59        $Id: email2trac.py.in 359 2010-05-19 13:30:25Z Blackhex $
60"""
61import os
62import sys
63import string
64import getopt
65import stat
66import time
67import email
68import email.Iterators
69import email.Header
70import re
71import urllib
72import unicodedata
73from stat import *
74import mimetypes
75import traceback
76
77
78# Will fail where unavailable, e.g. Windows
79#
80try:
81    import syslog
82    SYSLOG_AVAILABLE = True
83except ImportError:
84    SYSLOG_AVAILABLE = False
85
86from datetime import tzinfo, timedelta, datetime
87from trac import config as trac_config
88
89# Some global variables
90#
91trac_default_version = '0.11'
92m = None
93
94# A UTC class needed for trac version 0.11, added by
95# tbaschak at ktc dot mb dot ca
96#
97class UTC(tzinfo):
98        """UTC"""
99        ZERO = timedelta(0)
100        HOUR = timedelta(hours=1)
101       
102        def utcoffset(self, dt):
103                return self.ZERO
104               
105        def tzname(self, dt):
106                return "UTC"
107               
108        def dst(self, dt):
109                return self.ZERO
110
111
112class TicketEmailParser(object):
113        env = None
114        comment = '> '
115
116        def __init__(self, env, parameters, version):
117                self.env = env
118
119                # Database connection
120                #
121                self.db = None
122
123                # Save parameters
124                #
125                self.parameters = parameters
126
127                # Some useful mail constants
128                #
129                self.email_name = None
130                self.email_addr = None
131                self.email_from = None
132                self.author     = None
133                self.id         = None
134               
135                self.STRIP_CONTENT_TYPES = list()
136
137                self.VERSION = version
138                self.DRY_RUN = parameters['dry_run']
139                self.VERBOSE = parameters['verbose']
140
141                self.get_config = self.env.config.get
142
143                if parameters.has_key('umask'):
144                        os.umask(int(parameters['umask'], 8))
145
146                if parameters.has_key('debug'):
147                        self.DEBUG = int(parameters['debug'])
148                else:
149                        self.DEBUG = 0
150
151                if parameters.has_key('mailto_link'):
152                        self.MAILTO = int(parameters['mailto_link'])
153                        if parameters.has_key('mailto_cc'):
154                                self.MAILTO_CC = parameters['mailto_cc']
155                        else:
156                                self.MAILTO_CC = ''
157                else:
158                        self.MAILTO = 0
159
160                if parameters.has_key('spam_level'):
161                        self.SPAM_LEVEL = int(parameters['spam_level'])
162                else:
163                        self.SPAM_LEVEL = 0
164
165                if parameters.has_key('spam_header'):
166                        self.SPAM_HEADER = parameters['spam_header']
167                else:
168                        self.SPAM_HEADER = 'X-Spam-Score'
169
170                if parameters.has_key('email_quote'):
171                        self.EMAIL_QUOTE = str(parameters['email_quote'])
172                else:   
173                        self.EMAIL_QUOTE = '> '
174
175                if parameters.has_key('email_header'):
176                        self.EMAIL_HEADER = int(parameters['email_header'])
177                else:
178                        self.EMAIL_HEADER = 0
179
180                if parameters.has_key('alternate_notify_template'):
181                        self.notify_template = str(parameters['alternate_notify_template'])
182                else:
183                        self.notify_template = None
184
185                if parameters.has_key('alternate_notify_template_update'):
186                        self.notify_template_update = str(parameters['alternate_notify_template_update'])
187                else:
188                        self.notify_template_update = None
189
190                if parameters.has_key('reply_all'):
191                        self.REPLY_ALL = int(parameters['reply_all'])
192                else:
193                        self.REPLY_ALL = 0
194
195                if parameters.has_key('ticket_update'):
196                        self.TICKET_UPDATE = int(parameters['ticket_update'])
197                else:
198                        self.TICKET_UPDATE = 0
199
200                if parameters.has_key('ticket_update_by_subject'):
201                        self.TICKET_UPDATE_BY_SUBJECT = int(parameters['ticket_update_by_subject'])
202                else:
203                        self.TICKET_UPDATE_BY_SUBJECT = 0
204
205                if parameters.has_key('drop_spam'):
206                        self.DROP_SPAM = int(parameters['drop_spam'])
207                else:
208                        self.DROP_SPAM = 0
209
210                if parameters.has_key('verbatim_format'):
211                        self.VERBATIM_FORMAT = int(parameters['verbatim_format'])
212                else:
213                        self.VERBATIM_FORMAT = 1
214
215                if parameters.has_key('reflow'):
216                        self.REFLOW = int(parameters['reflow'])
217                else:
218                        self.REFLOW = 1
219
220                if parameters.has_key('drop_alternative_html_version'):
221                        self.DROP_ALTERNATIVE_HTML_VERSION = int(parameters['drop_alternative_html_version'])
222                else:
223                        self.DROP_ALTERNATIVE_HTML_VERSION = 0
224
225                if parameters.has_key('strip_signature'):
226                        self.STRIP_SIGNATURE = int(parameters['strip_signature'])
227                else:
228                        self.STRIP_SIGNATURE = 0
229
230                if parameters.has_key('strip_quotes'):
231                        self.STRIP_QUOTES = int(parameters['strip_quotes'])
232                else:
233                        self.STRIP_QUOTES = 0
234
235                self.properties = dict()
236                if parameters.has_key('inline_properties'):
237                        self.INLINE_PROPERTIES = int(parameters['inline_properties'])
238                else:
239                        self.INLINE_PROPERTIES = 0
240
241                if parameters.has_key('use_textwrap'):
242                        self.USE_TEXTWRAP = int(parameters['use_textwrap'])
243                else:
244                        self.USE_TEXTWRAP = 0
245
246                if parameters.has_key('binhex'):
247                        self.STRIP_CONTENT_TYPES.append('application/mac-binhex40')
248
249                if parameters.has_key('applesingle'):
250                        self.STRIP_CONTENT_TYPES.append('application/applefile')
251
252                if parameters.has_key('appledouble'):
253                        self.STRIP_CONTENT_TYPES.append('application/applefile')
254
255                if parameters.has_key('strip_content_types'):
256                        items = parameters['strip_content_types'].split(',')
257                        for item in items:
258                                self.STRIP_CONTENT_TYPES.append(item.strip())
259
260                self.WORKFLOW = None
261                if parameters.has_key('workflow'):
262                        self.WORKFLOW = parameters['workflow']
263
264                # Use OS independend functions
265                #
266                self.TMPDIR = os.path.normcase('/tmp')
267                if parameters.has_key('tmpdir'):
268                        self.TMPDIR = os.path.normcase(str(parameters['tmpdir']))
269
270                if parameters.has_key('ignore_trac_user_settings'):
271                        self.IGNORE_TRAC_USER_SETTINGS = int(parameters['ignore_trac_user_settings'])
272                else:
273                        self.IGNORE_TRAC_USER_SETTINGS = 0
274
275                if parameters.has_key('email_triggers_workflow'):
276                        self.EMAIL_TRIGGERS_WORKFLOW = int(parameters['email_triggers_workflow'])
277                else:
278                        self.EMAIL_TRIGGERS_WORKFLOW = 1
279
280                if parameters.has_key('subject_field_separator'):
281                        self.SUBJECT_FIELD_SEPARATOR = parameters['subject_field_separator'].strip()
282                else:
283                        self.SUBJECT_FIELD_SEPARATOR = '&'
284
285                self.trac_smtp_from = self.get_config('notification', 'smtp_from')
286
287                self.system = None
288
289########## Email Header Functions ###########################################################
290
291        def spam(self, message):
292                """
293                # X-Spam-Score: *** (3.255) BAYES_50,DNS_FROM_AHBL_RHSBL,HTML_
294                # Note if Spam_level then '*' are included
295                """
296                spam = False
297                if message.has_key(self.SPAM_HEADER):
298                        spam_l = string.split(message[self.SPAM_HEADER])
299
300                        try:
301                                number = spam_l[0].count('*')
302                        except IndexError, detail:
303                                number = 0
304                               
305                        if number >= self.SPAM_LEVEL:
306                                spam = True
307                               
308                # treat virus mails as spam
309                #
310                elif message.has_key('X-Virus-found'):                 
311                        spam = True
312
313                # How to handle SPAM messages
314                #
315                if self.DROP_SPAM and spam:
316                        if self.DEBUG > 2 :
317                                print 'This message is a SPAM. Automatic ticket insertion refused (SPAM level > %d' % self.SPAM_LEVEL
318
319                        return 'drop'   
320
321                elif spam:
322
323                        return 'Spam'   
324
325                else:
326
327                        return False
328
329        def email_header_acl(self, keyword, header_field, default):
330                """
331                This function wil check if the email address is allowed or denied
332                to send mail to the ticket list
333            """
334                try:
335                        mail_addresses = self.parameters[keyword]
336
337                        # Check if we have an empty string
338                        #
339                        if not mail_addresses:
340                                return default
341
342                except KeyError, detail:
343                        if self.DEBUG > 2 :
344                                print 'TD: %s not defined, all messages are allowed.' %(keyword)
345
346                        return default
347
348                mail_addresses = string.split(mail_addresses, ',')
349
350                for entry in mail_addresses:
351                        entry = entry.strip()
352                        TO_RE = re.compile(entry, re.VERBOSE|re.IGNORECASE)
353                        result =  TO_RE.search(header_field)
354                        if result:
355                                return True
356
357                return False
358
359        def email_header_txt(self, m):
360                """
361                Display To and CC addresses in description field
362                """
363                s = ''
364
365                if m['To'] and len(m['To']) > 0:
366                        s = "'''To:''' %s\r\n" %(m['To'])
367                if m['Cc'] and len(m['Cc']) > 0:
368                        s = "%s'''Cc:''' %s\r\n" % (s, m['Cc'])
369
370                return  self.email_to_unicode(s)
371
372
373        def get_sender_info(self, message):
374                """
375                Get the default author name and email address from the message
376                """
377
378                self.email_to = self.email_to_unicode(message['to'])
379                self.to_name, self.to_email_addr = email.Utils.parseaddr (self.email_to)
380
381                self.email_from = self.email_to_unicode(message['from'])
382                self.email_name, self.email_addr  = email.Utils.parseaddr(self.email_from)
383
384                ## Trac can not handle author's name that contains spaces
385                #  and forbid the ticket email address as author field
386
387                if self.email_addr == self.trac_smtp_from:
388                        self.author = "email2trac"
389                else:
390                        self.author = self.email_addr
391
392                if self.IGNORE_TRAC_USER_SETTINGS:
393                        return
394
395                # Is this a registered user, use email address as search key:
396                # result:
397                #   u : login name
398                #   n : Name that the user has set in the settings tab
399                #   e : email address that the user has set in the settings tab
400                #
401                users = [ (u,n,e) for (u, n, e) in self.env.get_known_users(self.db)
402                        if e and (e.lower() == self.email_addr.lower()) ]
403
404                if len(users) == 1:
405                        self.email_from = users[0][0]
406                        self.author = users[0][0]
407
408        def set_reply_fields(self, ticket, message):
409                """
410                Set all the right fields for a new ticket
411                """
412                if self.DEBUG:
413                        print 'TD: set_reply_fields'
414
415                ## Only use name or email adress
416                #ticket['reporter'] = self.email_from
417                ticket['reporter'] = self.author
418
419
420                # Put all CC-addresses in ticket CC field
421                #
422                if self.REPLY_ALL:
423
424                        email_cc = ''
425
426                        cc_addrs = email.Utils.getaddresses( message.get_all('cc', []) )
427
428                        if not cc_addrs:
429                                return
430
431                        ## Build a list of forbidden CC addresses
432                        #
433                        #to_addrs = email.Utils.getaddresses( message.get_all('to', []) )
434                        #to_list = list()
435                        #for n,e in to_addrs:
436                        #       to_list.append(e)
437                               
438                        # Remove reporter email address if notification is
439                        # on
440                        #
441                        if self.notification:
442                                try:
443                                        cc_addrs.remove((self.author, self.email_addr))
444                                except ValueError, detail:
445                                        pass
446
447                        for name,addr in cc_addrs:
448               
449                                ## Prevent mail loop
450                                #
451                                #if addr in to_list:
452
453                                if addr == self.trac_smtp_from:
454                                        if self.DEBUG:
455                                                print "Skipping %s mail address for CC-field" %(addr)
456                                        continue
457
458                                if email_cc:
459                                        email_cc = '%s, %s' %(email_cc, addr)
460                                else:
461                                        email_cc = addr
462
463                        if email_cc:
464                                if self.DEBUG:
465                                        print 'TD: set_reply_fields: %s' %email_cc
466
467                                ticket['cc'] = self.email_to_unicode(email_cc)
468
469
470########## DEBUG functions  ###########################################################
471
472        def debug_body(self, message_body, tempfile=False):
473                if tempfile:
474                        import tempfile
475                        body_file = tempfile.mktemp('.email2trac')
476                else:
477                        body_file = os.path.join(self.TMPDIR, 'body.txt')
478
479                if self.DRY_RUN:
480                        print 'DRY-RUN: not saving body to %s' %(body_file)
481                        return
482
483                print 'TD: writing body to %s' %(body_file)
484                fx = open(body_file, 'wb')
485                if not message_body:
486                                message_body = '(None)'
487
488                message_body = message_body.encode('utf-8')
489                #message_body = unicode(message_body, 'iso-8859-15')
490
491                fx.write(message_body)
492                fx.close()
493                try:
494                        os.chmod(body_file,S_IRWXU|S_IRWXG|S_IRWXO)
495                except OSError:
496                        pass
497
498        def debug_attachments(self, message_parts):
499                """
500                """
501                if self.VERBOSE:
502                        print "VB: debug_attachments"
503               
504                n = 0
505                for item in message_parts:
506                        # Skip inline text parts
507                        if not isinstance(item, tuple):
508                                continue
509                               
510                        (original, filename, part) = item
511
512                        n = n + 1
513                        print 'TD: part%d: Content-Type: %s' % (n, part.get_content_type())
514                        print 'TD: part%d: filename: %s' % (n, filename)
515
516                        ## Forbidden chars
517                        #
518                        filename = filename.replace('\\', '_')
519                        filename = filename.replace('/', '_')
520       
521
522                        part_file = os.path.join(self.TMPDIR, filename)
523                        print 'TD: writing part%d (%s)' % (n,part_file)
524
525                        if self.DRY_RUN:
526                                print 'DRY_RUN: NOT saving attachments'
527                                continue
528
529                        fx = open(part_file, 'wb')
530                        text = part.get_payload(decode=1)
531
532                        if not text:
533                                text = '(None)'
534
535                        fx.write(text)
536                        fx.close()
537
538                        try:
539                                os.chmod(part_file,S_IRWXU|S_IRWXG|S_IRWXO)
540                        except OSError:
541                                pass
542
543        def save_email_for_debug(self, message, tempfile=False):
544
545                if tempfile:
546                        import tempfile
547                        msg_file = tempfile.mktemp('.email2trac')
548                else:
549                        #msg_file = '/var/tmp/msg.txt'
550                        msg_file = os.path.join(self.TMPDIR, 'msg.txt')
551
552                if self.DRY_RUN:
553                        print 'DRY_RUN: NOT saving email message to %s' %(msg_file)
554                else:
555                        print 'TD: saving email to %s' %(msg_file)
556
557                        fx = open(msg_file, 'wb')
558                        fx.write('%s' % message)
559                        fx.close()
560                       
561                        try:
562                                os.chmod(msg_file,S_IRWXU|S_IRWXG|S_IRWXO)
563                        except OSError:
564                                pass
565
566                message_parts = self.get_message_parts(message)
567                message_parts = self.unique_attachment_names(message_parts)
568                body_text = self.body_text(message_parts)
569                self.debug_body(body_text, True)
570                self.debug_attachments(message_parts)
571
572########## Conversion functions  ###########################################################
573
574        def email_to_unicode(self, message_str):
575                """
576                Email has 7 bit ASCII code, convert it to unicode with the charset
577                that is encoded in 7-bit ASCII code and encode it as utf-8 so Trac
578                understands it.
579                """
580                if self.VERBOSE:
581                        print "VB: email_to_unicode"
582
583                results =  email.Header.decode_header(message_str)
584
585                s = None
586                for text,format in results:
587                        if format:
588                                try:
589                                        temp = unicode(text, format)
590                                except UnicodeError, detail:
591                                        # This always works
592                                        #
593                                        temp = unicode(text, 'iso-8859-15')
594                                except LookupError, detail:
595                                        #text = 'ERROR: Could not find charset: %s, please install' %format
596                                        #temp = unicode(text, 'iso-8859-15')
597                                        temp = message_str
598                                       
599                        else:
600                                temp = string.strip(text)
601                                temp = unicode(text, 'iso-8859-15')
602
603                        if s:
604                                s = '%s %s' %(s, temp)
605                        else:
606                                s = '%s' %temp
607
608                #s = s.encode('utf-8')
609                return s
610
611        def str_to_dict(self, s):
612                """
613                Transfrom a string of the form [<key>=<value>]+ to dict[<key>] = <value>
614                """
615                if self.VERBOSE:
616                        print "VB: str_to_dict"
617
618                fields = string.split(s, self.SUBJECT_FIELD_SEPARATOR)
619
620                result = dict()
621                for field in fields:
622                        try:
623                                index, value = string.split(field, '=')
624
625                                # We can not change the description of a ticket via the subject
626                                # line. The description is the body of the email
627                                #
628                                if index.lower() in ['description']:
629                                        continue
630
631                                if value:
632                                        result[index.lower()] = value
633
634                        except ValueError:
635                                pass
636                return result
637
638########## TRAC ticket functions  ###########################################################
639
640        def update_ticket_fields(self, ticket, user_dict, use_default=None):
641                """
642                This will update the ticket fields. It will check if the
643                given fields are known and if the right values are specified
644                It will only update the ticket field value:
645                        - If the field is known
646                        - If the value supplied is valid for the ticket field.
647                          If not then there are two options:
648                           1) Skip the value (use_default=None)
649                           2) Set default value for field (use_default=1)
650                """
651                if self.VERBOSE:
652                        print "VB: update_ticket_fields"
653
654                # Build a system dictionary from the ticket fields
655                # with field as index and option as value
656                #
657                sys_dict = dict()
658                for field in ticket.fields:
659                        try:
660                                sys_dict[field['name']] = field['options']
661
662                        except KeyError:
663                                sys_dict[field['name']] = None
664                                pass
665
666                ## Check user supplied fields an compare them with the
667                # system one's
668                #
669                for field,value in user_dict.items():
670                        if self.DEBUG >= 10:
671                                print  'user_field\t %s = %s' %(field,value)
672
673                        ## To prevent mail loop
674                        #
675                        if field == 'cc':
676
677                                cc_list = user_dict['cc'].split(',')
678
679                                if self.trac_smtp_from in cc_list:
680                                        if self.DEBUG > 10:
681                                                print 'TD: MAIL LOOP: %s is not allowed as CC address' %(self.trac_smtp_from)
682                                        cc_list.remove(self.trac_smtp_from)
683
684                                value = ','.join(cc_list)
685                               
686
687                        if sys_dict.has_key(field):
688
689                                # Check if value is an allowed system option, if TypeError then
690                                # every value is allowed
691                                #
692                                try:
693                                        if value in sys_dict[field]:
694                                                ticket[field] = value
695                                        else:
696                                                # Must we set a default if value is not allowed
697                                                #
698                                                if use_default:
699                                                        value = self.get_config('ticket', 'default_%s' %(field) )
700
701                                except TypeError:
702                                        pass
703
704                                ## Only set if we have a value
705                                #
706                                if value:
707                                        ticket[field] = value
708
709                                if self.DEBUG >= 10:
710                                        print  'ticket_field\t %s = %s' %(field,  ticket[field])
711
712        def ticket_update(self, m, id, spam):
713                """
714                If the current email is a reply to an existing ticket, this function
715                will append the contents of this email to that ticket, instead of
716                creating a new one.
717                """
718                if self.VERBOSE:
719                        print "VB: ticket_update: %s" %id
720
721                # Must we update ticket fields
722                #
723                update_fields = dict()
724                try:
725                        id, keywords = string.split(id, '?')
726
727                        # Skip the last ':' character
728                        #
729                        keywords = keywords[:-1]
730                        update_fields = self.str_to_dict(keywords)
731
732                        # Strip '#'
733                        #
734                        self.id = int(id[1:])
735
736                except ValueError:
737                        # Strip '#' and ':'
738                        #
739                        self.id = int(id[1:-1])
740
741
742                # When is the change committed
743                #
744                if self.VERSION == 0.11:
745                        utc = UTC()
746                        when = datetime.now(utc)
747                else:
748                        when = int(time.time())
749
750                try:
751                        tkt = Ticket(self.env, self.id, self.db)
752                except util.TracError, detail:
753                        # Not a valid ticket
754                        self.id = None
755                        return False
756
757                # How many changes has this ticket
758                cnum = len(tkt.get_changelog())
759
760
761                # reopen the ticket if it is was closed
762                # We must use the ticket workflow framework
763                #
764                if tkt['status'] in ['closed'] and self.EMAIL_TRIGGERS_WORKFLOW:
765
766                        #print controller.actions['reopen']
767                        #
768                        # As reference 
769                        # req = Mock(href=Href('/'), abs_href=Href('http://www.example.com/'), authname='anonymous', perm=MockPerm(), args={})
770                        #
771                        #a = controller.render_ticket_action_control(req, tkt, 'reopen')
772                        #print 'controller : ', a
773                        #
774                        #b = controller.get_all_status()
775                        #print 'get all status: ', b
776                        #
777                        #b = controller.get_ticket_changes(req, tkt, 'reopen')
778                        #print 'get_ticket_changes :', b
779
780                        if self.WORKFLOW and (self.VERSION in [0.11]) :
781                                from trac.ticket.default_workflow import ConfigurableTicketWorkflow
782                                from trac.test import Mock, MockPerm
783
784                                req = Mock(authname='anonymous', perm=MockPerm(), args={})
785
786                                controller = ConfigurableTicketWorkflow(self.env)
787                                fields = controller.get_ticket_changes(req, tkt, self.WORKFLOW)
788
789                                if self.DEBUG:
790                                        print 'TD: Workflow ticket update fields: ', fields
791
792                                for key in fields.keys():
793                                        tkt[key] = fields[key]
794
795                        else:
796                                tkt['status'] = 'reopened'
797                                tkt['resolution'] = ''
798
799                # Must we update some ticket fields properties via subjectline
800                #
801                if update_fields:
802                        self.update_ticket_fields(tkt, update_fields)
803
804                message_parts = self.get_message_parts(m)
805                message_parts = self.unique_attachment_names(message_parts)
806
807                # Must we update some ticket fields properties via body_text
808                #
809                if self.properties:
810                                self.update_ticket_fields(tkt, self.properties)
811
812                if self.EMAIL_HEADER:
813                        message_parts.insert(0, self.email_header_txt(m))
814
815                body_text = self.body_text(message_parts)
816
817                if self.VERSION  == 0.9:
818                        error_with_attachments = self.attach_attachments(message_parts, True)
819                else:
820                        error_with_attachments = self.attach_attachments(message_parts)
821
822                if body_text.strip() or update_fields or self.properties:
823                        if self.DRY_RUN:
824                                print 'DRY_RUN: tkt.save_changes(self.author, body_text, ticket_change_number) ', self.author, cnum
825                        else:
826                                if error_with_attachments:
827                                        body_text = '%s\\%s' %(error_with_attachments, body_text)
828                               
829                                tkt.save_changes(self.author, body_text, when, None, str(cnum))
830                       
831
832                #if self.VERSION  == 0.9:
833                #       error_with_attachments = self.attach_attachments(message_parts, True)
834                #else:
835                #       error_with_attachments = self.attach_attachments(message_parts)
836
837                if self.notification and not spam:
838                        self.notify(tkt, False, when)
839
840                return True
841
842        def set_ticket_fields(self, ticket):
843                """
844                set the ticket fields to value specified
845                        - /etc/email2trac.conf with <prefix>_<field>
846                        - trac default values, trac.ini
847                """
848                user_dict = dict()
849
850                for field in ticket.fields:
851
852                        name = field['name']
853
854                        ## default trac value
855                        #
856                        if not field.get('custom'):
857                                value = self.get_config('ticket', 'default_%s' %(name) )
858                        else:
859                                ##  Else we get the default value for reporter
860                                #
861                                value = field.get('value')
862                                options = field.get('options')
863
864                                if value and options and (value not in options):
865                                         value = options[int(value)]
866       
867                        if self.DEBUG > 10:
868                                print 'trac.ini name %s = %s' %(name, value)
869
870                        ## email2trac.conf settings
871                        #
872                        prefix = self.parameters['ticket_prefix']
873                        try:
874                                value = self.parameters['%s_%s' %(prefix, name)]
875                                if self.DEBUG > 10:
876                                        print 'email2trac.conf %s = %s ' %(name, value)
877
878                        except KeyError, detail:
879                                pass
880               
881                        if self.DEBUG:
882                                print 'user_dict[%s] = %s' %(name, value)
883
884                        if value:
885                                user_dict[name] = value
886
887                self.update_ticket_fields(ticket, user_dict, use_default=1)
888
889                if 'status' not in user_dict.keys():
890                        ticket['status'] = 'new'
891
892
893        def ticket_update_by_subject(self, subject):
894                """
895                This list of Re: prefixes is probably incomplete. Taken from
896                wikipedia. Here is how the subject is matched
897                  - Re: <subject>
898                  - Re: (<Mail list label>:)+ <subject>
899
900                So we must have the last column
901                """
902                if self.VERBOSE:
903                        print "VB: ticket_update_by_subject()"
904
905                matched_id = None
906                if self.TICKET_UPDATE and self.TICKET_UPDATE_BY_SUBJECT:
907                               
908                        SUBJECT_RE = re.compile(r'^(RE|AW|VS|SV):(.*:)*\s*(.*)', re.IGNORECASE)
909                        result = SUBJECT_RE.search(subject)
910
911                        if result:
912                                # This is a reply
913                                orig_subject = result.group(3)
914
915                                if self.DEBUG:
916                                        print 'TD: subject search string: %s' %(orig_subject)
917
918                                cursor = self.db.cursor()
919                                summaries = [orig_subject, '%%: %s' % orig_subject]
920
921                                # hard-code the time to 30 days for now. Can easily be
922                                # made configurable
923                                lookback = int(time.mktime(time.gmtime())) - 2592000
924
925                                for summary in summaries:
926                                        if self.DEBUG:
927                                                print 'TD: Looking for summary matching: "%s"' % summary
928                                        sql = """SELECT id FROM ticket
929                                                        WHERE changetime >= %s AND summary LIKE %s
930                                                        ORDER BY changetime DESC"""
931                                        cursor.execute(sql, [lookback, summary.strip()])
932
933                                        for row in cursor:
934                                                (matched_id,) = row
935                                                if self.DEBUG:
936                                                        print 'TD: Found matching ticket id: %d' % matched_id
937                                                break
938
939                                        if matched_id:
940                                                matched_id = '#%d:' % matched_id
941                                                return matched_id
942
943                return matched_id
944
945
946        def new_ticket(self, msg, subject, spam, set_fields = None):
947                """
948                Create a new ticket
949                """
950                if self.VERBOSE:
951                        print "VB: function new_ticket()"
952
953                tkt = Ticket(self.env)
954
955                self.set_reply_fields(tkt, msg)
956
957                self.set_ticket_fields(tkt)
958
959                # Old style setting for component, will be removed
960                #
961                if spam:
962                        tkt['component'] = 'Spam'
963
964                elif self.parameters.has_key('component'):
965                        tkt['component'] = self.parameters['component']
966
967                if not msg['Subject']:
968                        tkt['summary'] = u'(No subject)'
969                else:
970                        tkt['summary'] = subject
971
972
973                if set_fields:
974                        rest, keywords = string.split(set_fields, '?')
975
976                        if keywords:
977                                update_fields = self.str_to_dict(keywords)
978                                self.update_ticket_fields(tkt, update_fields)
979
980                # produce e-mail like header
981                #
982                head = ''
983                if self.EMAIL_HEADER > 0:
984                        head = self.email_header_txt(msg)
985
986                message_parts = self.get_message_parts(msg)
987
988                # Must we update some ticket fields properties via body_text
989                #
990                if self.properties:
991                                self.update_ticket_fields(tkt, self.properties)
992
993                if self.DEBUG:
994                        print 'TD: self.get_message_parts ',
995                        print message_parts
996
997                message_parts = self.unique_attachment_names(message_parts)
998                if self.DEBUG:
999                        print 'TD: self.unique_attachment_names',
1000                        print message_parts
1001               
1002                if self.EMAIL_HEADER > 0:
1003                        message_parts.insert(0, self.email_header_txt(msg))
1004                       
1005                body_text = self.body_text(message_parts)
1006
1007                tkt['description'] = body_text
1008
1009                #when = int(time.time())
1010                #
1011                utc = UTC()
1012                when = datetime.now(utc)
1013
1014                if not self.DRY_RUN:
1015                        self.id = tkt.insert()
1016       
1017                changed = False
1018                comment = ''
1019
1020                # some routines in trac are dependend on ticket id     
1021                # like alternate notify template
1022                #
1023                if self.notify_template:
1024                        tkt['id'] = self.id
1025                        changed = True
1026
1027                ## Rewrite the description if we have mailto enabled
1028                #
1029                if self.MAILTO:
1030                        changed = True
1031                        comment = u'\nadded mailto line\n'
1032                        mailto = self.html_mailto_link( m['Subject'])
1033
1034                        tkt['description'] = u'%s\r\n%s%s\r\n' \
1035                                %(head, mailto, body_text)
1036       
1037                ## Save the attachments to the ticket   
1038                #
1039                error_with_attachments =  self.attach_attachments(message_parts)
1040
1041                if error_with_attachments:
1042                        changed = True
1043                        comment = '%s\n%s\n' %(comment, error_with_attachments)
1044
1045                if changed:
1046                        if self.DRY_RUN:
1047                                print 'DRY_RUN: tkt.save_changes(%s, comment) real reporter = %s' %( tkt['reporter'], self.author)
1048                        else:
1049                                tkt.save_changes(tkt['reporter'], comment)
1050                                #print tkt.get_changelog(self.db, when)
1051
1052                if self.notification and not spam:
1053                        self.notify(tkt, True)
1054
1055
1056        def attach_attachments(self, message_parts, update=False):
1057                '''
1058                save any attachments as files in the ticket's directory
1059                '''
1060                if self.VERBOSE:
1061                        print "VB: attach_attachments()"
1062
1063                if self.DRY_RUN:
1064                        print "DRY_RUN: no attachments attached to tickets"
1065                        return ''
1066
1067                count = 0
1068
1069                # Get Maxium attachment size
1070                #
1071                max_size = int(self.get_config('attachment', 'max_size'))
1072                status   = None
1073               
1074                for item in message_parts:
1075                        # Skip body parts
1076                        if not isinstance(item, tuple):
1077                                continue
1078                               
1079                        (original, filename, part) = item
1080                        #
1081                        # Must be tuneables HvB
1082                        #
1083                        path, fd =  util.create_unique_file(os.path.join(self.TMPDIR, filename))
1084                        text = part.get_payload(decode=1)
1085                        if not text:
1086                                text = '(None)'
1087                        fd.write(text)
1088                        fd.close()
1089
1090                        # get the file_size
1091                        #
1092                        stats = os.lstat(path)
1093                        file_size = stats[stat.ST_SIZE]
1094
1095                        # Check if the attachment size is allowed
1096                        #
1097                        if (max_size != -1) and (file_size > max_size):
1098                                status = '%s\nFile %s is larger then allowed attachment size (%d > %d)\n\n' \
1099                                        %(status, original, file_size, max_size)
1100
1101                                os.unlink(path)
1102                                continue
1103                        else:
1104                                count = count + 1
1105                                       
1106                        # Insert the attachment
1107                        #
1108                        fd = open(path, 'rb')
1109                        if self.system == 'discussion':
1110                                att = attachment.Attachment(self.env, 'discussion', 'topic/%s'
1111                                  % (self.id,))
1112                        else:
1113                                att = attachment.Attachment(self.env, 'ticket', self.id)
1114 
1115                        # This will break the ticket_update system, the body_text is vaporized
1116                        # ;-(
1117                        #
1118                        if not update:
1119                                att.author = self.author
1120                                att.description = self.email_to_unicode('Added by email2trac')
1121
1122                        try:
1123                                att.insert(filename, fd, file_size)
1124                        except OSError, detail:
1125                                status = '%s\nFilename %s could not be saved, problem: %s' %(status, filename, detail)
1126
1127                        # Remove the created temporary filename
1128                        #
1129                        fd.close()
1130                        os.unlink(path)
1131
1132                ## return error
1133                #
1134                return status
1135
1136########## Fullblog functions  #################################################
1137
1138        def blog(self, id):
1139                """
1140                The blog create/update function
1141                """
1142                # import the modules
1143                #
1144                from tracfullblog.core import FullBlogCore
1145                from tracfullblog.model import BlogPost, BlogComment
1146                from trac.test import Mock, MockPerm
1147
1148                # instantiate blog core
1149                blog = FullBlogCore(self.env)
1150                req = Mock(authname='anonymous', perm=MockPerm(), args={})
1151
1152                if id:
1153
1154                        # update blog
1155                        #
1156                        comment = BlogComment(self.env, id)
1157                        comment.author = self.author
1158
1159                        message_parts = self.get_message_parts(m)
1160                        comment.comment = self.body_text(message_parts)
1161
1162                        blog.create_comment(req, comment)
1163
1164                else:
1165                        # create blog
1166                        #
1167                        import time
1168                        post = BlogPost(self.env, 'blog_'+time.strftime("%Y%m%d%H%M%S", time.gmtime()))
1169
1170                        #post = BlogPost(self.env, blog._get_default_postname(self.env))
1171                       
1172                        post.author = self.author
1173                        post.title = self.email_to_unicode(m['Subject'])
1174
1175                        message_parts = self.get_message_parts(m)
1176                        post.body = self.body_text(message_parts)
1177                       
1178                        blog.create_post(req, post, self.author, u'Created by email2trac', False)
1179
1180
1181########## Discussion functions  ##############################################
1182
1183        def discussion_topic(self, content, subject):
1184
1185                # Import modules.
1186                from tracdiscussion.api import DiscussionApi
1187                from trac.util.datefmt import to_timestamp, utc
1188
1189                if self.DEBUG:
1190                        print 'TD: Creating a new topic in forum:', self.id
1191
1192                # Get dissussion API component.
1193                api = self.env[DiscussionApi]
1194                context = self._create_context(content, subject)
1195
1196                # Get forum for new topic.
1197                forum = api.get_forum(context, self.id)
1198
1199                if not forum and self.DEBUG:
1200                        print 'ERROR: Replied forum doesn\'t exist'
1201
1202                # Prepare topic.
1203                topic = {'forum' : forum['id'],
1204                                 'subject' : context.subject,
1205                                 'time': to_timestamp(datetime.now(utc)),
1206                                 'author' : self.author,
1207                                 'subscribers' : [self.email_addr],
1208                                 'body' : self.body_text(context.content_parts)}
1209
1210                # Add topic to DB and commit it.
1211                self._add_topic(api, context, topic)
1212                self.db.commit()
1213
1214        def discussion_topic_reply(self, content, subject):
1215
1216                # Import modules.
1217                from tracdiscussion.api import DiscussionApi
1218                from trac.util.datefmt import to_timestamp, utc
1219
1220                if self.DEBUG:
1221                        print 'TD: Replying to discussion topic', self.id
1222
1223                # Get dissussion API component.
1224                api = self.env[DiscussionApi]
1225                context = self._create_context(content, subject)
1226
1227                # Get replied topic.
1228                topic = api.get_topic(context, self.id)
1229
1230                if not topic and self.DEBUG:
1231                        print 'ERROR: Replied topic doesn\'t exist'
1232
1233                # Prepare message.
1234                message = {'forum' : topic['forum'],
1235                                   'topic' : topic['id'],
1236                                   'replyto' : -1,
1237                                   'time' : to_timestamp(datetime.now(utc)),
1238                                   'author' : self.author,
1239                                   'body' : self.body_text(context.content_parts)}
1240
1241                # Add message to DB and commit it.
1242                self._add_message(api, context, message)
1243                self.db.commit()
1244
1245        def discussion_message_reply(self, content, subject):
1246
1247                # Import modules.
1248                from tracdiscussion.api import DiscussionApi
1249                from trac.util.datefmt import to_timestamp, utc
1250
1251                if self.DEBUG:
1252                        print 'TD: Replying to discussion message', self.id
1253
1254                # Get dissussion API component.
1255                api = self.env[DiscussionApi]
1256                context = self._create_context(content, subject)
1257
1258                # Get replied message.
1259                message = api.get_message(context, self.id)
1260
1261                if not message and self.DEBUG:
1262                        print 'ERROR: Replied message doesn\'t exist'
1263
1264                # Prepare message.
1265                message = {'forum' : message['forum'],
1266                                   'topic' : message['topic'],
1267                                   'replyto' : message['id'],
1268                                   'time' : to_timestamp(datetime.now(utc)),
1269                                   'author' : self.author,
1270                                   'body' : self.body_text(context.content_parts)}
1271
1272                # Add message to DB and commit it.
1273                self._add_message(api, context, message)
1274                self.db.commit()
1275
1276        def _create_context(self, content, subject):
1277
1278                # Import modules.
1279                from trac.mimeview import Context
1280                from trac.web.api import Request
1281                from trac.perm import PermissionCache
1282
1283                # TODO: Read server base URL from config.
1284                # Create request object to mockup context creation.
1285                #
1286                environ = {'SERVER_PORT' : 80,
1287                                   'SERVER_NAME' : 'test',
1288                                   'REQUEST_METHOD' : 'POST',
1289                                   'wsgi.url_scheme' : 'http',
1290                                   'wsgi.input' : sys.stdin}
1291                chrome =  {'links': {},
1292                                   'scripts': [],
1293                                   'ctxtnav': [],
1294                                   'warnings': [],
1295                                   'notices': []}
1296
1297                if self.env.base_url_for_redirect:
1298                        environ['trac.base_url'] = self.env.base_url
1299
1300                req = Request(environ, None)
1301                req.chrome = chrome
1302                req.tz = 'missing'
1303                req.authname = self.author
1304                req.perm = PermissionCache(self.env, self.author)
1305
1306                # Create and return context.
1307                context = Context.from_request(req)
1308                context.realm = 'discussion-email2trac'
1309                context.cursor = self.db.cursor()
1310                context.content = content
1311                context.subject = subject
1312
1313                # Read content parts from content.
1314                context.content_parts = self.get_message_parts(content)
1315                context.content_parts = self.unique_attachment_names(
1316                  context.content_parts)
1317
1318                return context
1319
1320        def _add_topic(self, api, context, topic):
1321                context.req.perm.assert_permission('DISCUSSION_APPEND')
1322
1323                # Filter topic.
1324                for discussion_filter in api.discussion_filters:
1325                        accept, topic_or_error = discussion_filter.filter_topic(
1326                          context, topic)
1327                        if accept:
1328                                topic = topic_or_error
1329                        else:
1330                                raise TracError(topic_or_error)
1331
1332                # Add a new topic.
1333                api.add_topic(context, topic)
1334
1335                # Get inserted topic with new ID.
1336                topic = api.get_topic_by_time(context, topic['time'])
1337
1338                # Attach attachments.
1339                self.id = topic['id']
1340                self.attach_attachments(context.content_parts, self.VERSION == 0.9)
1341
1342                # Notify change listeners.
1343                for listener in api.topic_change_listeners:
1344                        listener.topic_created(context, topic)
1345
1346        def _add_message(self, api, context, message):
1347                context.req.perm.assert_permission('DISCUSSION_APPEND')
1348
1349                # Filter message.
1350                for discussion_filter in api.discussion_filters:
1351                        accept, message_or_error = discussion_filter.filter_message(
1352                          context, message)
1353                        if accept:
1354                                message = message_or_error
1355                        else:
1356                                raise TracError(message_or_error)
1357
1358                # Add message.
1359                api.add_message(context, message)
1360
1361                # Get inserted message with new ID.
1362                message = api.get_message_by_time(context, message['time'])
1363
1364                # Attach attachments.
1365                self.id = message['topic']
1366                self.attach_attachments(context.content_parts, self.VERSION == 0.9)
1367
1368                # Notify change listeners.
1369                for listener in api.message_change_listeners:
1370                        listener.message_created(context, message)
1371
1372########## MAIN function  ######################################################
1373
1374        def parse(self, fp):
1375                """
1376                """
1377                if self.VERBOSE:
1378                        print "VB: main function parse()"
1379                global m
1380
1381                m = email.message_from_file(fp)
1382               
1383                if not m:
1384                        if self.DEBUG:
1385                                print "TD: This is not a valid email message format"
1386                        return
1387                       
1388                # Work around lack of header folding in Python; see http://bugs.python.org/issue4696
1389                try:
1390                        m.replace_header('Subject', m['Subject'].replace('\r', '').replace('\n', ''))
1391                except AttributeError, detail:
1392                        pass
1393
1394                if self.DEBUG > 1:        # save the entire e-mail message text
1395                        self.save_email_for_debug(m, True)
1396
1397                self.db = self.env.get_db_cnx()
1398                self.get_sender_info(m)
1399
1400                if not self.email_header_acl('white_list', self.email_addr, True):
1401                        if self.DEBUG > 1 :
1402                                print 'Message rejected : %s not in white list' %(self.email_addr)
1403                        return False
1404
1405                if self.email_header_acl('black_list', self.email_addr, False):
1406                        if self.DEBUG > 1 :
1407                                print 'Message rejected : %s in black list' %(self.email_addr)
1408                        return False
1409
1410                if not self.email_header_acl('recipient_list', self.to_email_addr, True):
1411                        if self.DEBUG > 1 :
1412                                print 'Message rejected : %s not in recipient list' %(self.to_email_addr)
1413                        return False
1414
1415                # If drop the message
1416                #
1417                if self.spam(m) == 'drop':
1418                        return False
1419
1420                elif self.spam(m) == 'spam':
1421                        spam_msg = True
1422                else:
1423                        spam_msg = False
1424
1425                if self.get_config('notification', 'smtp_enabled') in ['true']:
1426                        self.notification = 1
1427                else:
1428                        self.notification = 0
1429
1430                if not m['Subject']:
1431                        subject  = 'No Subject'
1432                else:
1433                        subject  = self.email_to_unicode(m['Subject'])
1434
1435                if self.DEBUG:
1436                         print "TD:", subject
1437
1438                #
1439                # [hic] #1529: Re: LRZ
1440                # [hic] #1529?owner=bas,priority=medium: Re: LRZ
1441                #
1442                ticket_regex = r'''
1443                        (?P<new_fields>[#][?].*)
1444                        |(?P<reply>(?P<id>[#][\d]+)(?P<fields>\?.*?:)*)
1445                        '''
1446                # Check if  FullBlogPlugin is installed
1447                #
1448                blog_enabled = None
1449                blog_regex = ''
1450                if self.get_config('components', 'tracfullblog.*') in ['enabled']:
1451                        blog_enabled = True
1452                        blog_regex = '''|(?P<blog>blog:(?P<blog_id>\w*))'''
1453
1454
1455                # Check if DiscussionPlugin is installed
1456                #
1457                discussion_enabled = None
1458                discussion_regex = ''
1459                if self.get_config('components', 'tracdiscussion.api.*') in ['enabled']:
1460                        discussion_enabled = True
1461                        discussion_regex = r'''
1462                        |(?P<forum>Forum[ ][#](?P<forum_id>\d+)[ ]-[ ]?)
1463                        |(?P<topic>Topic[ ][#](?P<topic_id>\d+)[ ]-[ ]?)
1464                        |(?P<message>Message[ ][#](?P<message_id>\d+)[ ]-[ ]?)
1465                        '''
1466
1467
1468                regex_str = ticket_regex + blog_regex + discussion_regex
1469                SYSTEM_RE = re.compile(regex_str, re.VERBOSE)
1470
1471                # Find out if this is a ticket, a blog or a discussion
1472                #
1473                result =  SYSTEM_RE.search(subject)
1474                if result:
1475                        # update ticket + fields
1476                        #
1477                        if result.group('reply') and self.TICKET_UPDATE:
1478                                self.system = 'ticket'
1479                                self.ticket_update(m, result.group('reply'), spam_msg)
1480
1481                        # New ticket + fields
1482                        #
1483                        elif result.group('new_fields'):
1484                                self.system = 'ticket'
1485                                self.new_ticket(m, subject[:result.start('new_fields')], spam_msg, result.group('new_fields'))
1486
1487                        if blog_enabled:
1488                                if result.group('blog'):
1489                                        self.system = 'blog'
1490                                        self.blog(result.group('blog_id'))
1491
1492                        if discussion_enabled:
1493                                # New topic.
1494                                #
1495                                if result.group('forum'):
1496                                        self.system = 'discussion'
1497                                        self.id = int(result.group('forum_id'))
1498                                        self.discussion_topic(m, subject[result.end('forum'):])
1499
1500                                # Reply to topic.
1501                                #
1502                                elif result.group('topic'):
1503                                        self.system = 'discussion'
1504                                        self.id = int(result.group('topic_id'))
1505                                        self.discussion_topic_reply(m, subject[result.end('topic'):])
1506
1507                                # Reply to topic message.
1508                                #
1509                                elif result.group('message'):
1510                                        self.system = 'discussion'
1511                                        self.id = int(result.group('message_id'))
1512                                        self.discussion_message_reply(m, subject[result.end('message'):])
1513
1514                else:
1515                        self.system = 'ticket'
1516                        result = self.ticket_update_by_subject(subject)
1517                        if result:
1518                                self.ticket_update(m, result, spam_msg)
1519                        else:
1520                                # No update by subject, so just create a new ticket
1521                                self.new_ticket(m, subject, spam_msg)
1522
1523
1524########## BODY TEXT functions  ###########################################################
1525
1526        def strip_signature(self, text):
1527                """
1528                Strip signature from message, inspired by Mailman software
1529                """
1530                body = []
1531                for line in text.splitlines():
1532                        if line == '-- ':
1533                                break
1534                        body.append(line)
1535
1536                return ('\n'.join(body))
1537
1538        def reflow(self, text, delsp = 0):
1539                """
1540                Reflow the message based on the format="flowed" specification (RFC 3676)
1541                """
1542                flowedlines = []
1543                quotelevel = 0
1544                prevflowed = 0
1545
1546                for line in text.splitlines():
1547                        from re import match
1548                       
1549                        # Figure out the quote level and the content of the current line
1550                        m = match('(>*)( ?)(.*)', line)
1551                        linequotelevel = len(m.group(1))
1552                        line = m.group(3)
1553
1554                        # Determine whether this line is flowed
1555                        if line and line != '-- ' and line[-1] == ' ':
1556                                flowed = 1
1557                        else:
1558                                flowed = 0
1559
1560                        if flowed and delsp and line and line[-1] == ' ':
1561                                line = line[:-1]
1562
1563                        # If the previous line is flowed, append this line to it
1564                        if prevflowed and line != '-- ' and linequotelevel == quotelevel:
1565                                flowedlines[-1] += line
1566                        # Otherwise, start a new line
1567                        else:
1568                                flowedlines.append('>' * linequotelevel + line)
1569
1570                        prevflowed = flowed
1571                       
1572
1573                return '\n'.join(flowedlines)
1574
1575        def strip_quotes(self, text):
1576                """
1577                Strip quotes from message by Nicolas Mendoza
1578                """
1579                body = []
1580                for line in text.splitlines():
1581                        if line.startswith(self.EMAIL_QUOTE):
1582                                continue
1583                        body.append(line)
1584
1585                return ('\n'.join(body))
1586
1587        def inline_properties(self, text):
1588                """
1589                Parse text if we use inline keywords to set ticket fields
1590                """
1591                if self.DEBUG:
1592                        print 'TD: inline_properties function'
1593
1594                properties = dict()
1595                body = list()
1596
1597                INLINE_EXP = re.compile('\s*[@]\s*([a-zA-Z]+)\s*:(.*)$')
1598
1599                for line in text.splitlines():
1600                        match = INLINE_EXP.match(line)
1601                        if match:
1602                                keyword, value = match.groups()
1603                                self.properties[keyword] = value.strip()
1604                                if self.DEBUG:
1605                                        print "TD: inline properties: %s : %s" %(keyword,value)
1606                        else:
1607                                body.append(line)
1608                               
1609                return '\n'.join(body)
1610
1611
1612        def wrap_text(self, text, replace_whitespace = False):
1613                """
1614                Will break a lines longer then given length into several small
1615                lines of size given length
1616                """
1617                import textwrap
1618
1619                LINESEPARATOR = '\n'
1620                reformat = ''
1621
1622                for s in text.split(LINESEPARATOR):
1623                        tmp = textwrap.fill(s,self.USE_TEXTWRAP)
1624                        if tmp:
1625                                reformat = '%s\n%s' %(reformat,tmp)
1626                        else:
1627                                reformat = '%s\n' %reformat
1628
1629                return reformat
1630
1631                # Python2.4 and higher
1632                #
1633                #return LINESEPARATOR.join(textwrap.fill(s,width) for s in str.split(LINESEPARATOR))
1634                #
1635
1636########## EMAIL attachements functions ###########################################################
1637
1638        def inline_part(self, part):
1639                """
1640                """
1641                if self.VERBOSE:
1642                        print "VB: inline_part()"
1643
1644                return part.get_param('inline', None, 'Content-Disposition') == '' or not part.has_key('Content-Disposition')
1645
1646        def get_message_parts(self, msg):
1647                """
1648                parses the email message and returns a list of body parts and attachments
1649                body parts are returned as strings, attachments are returned as tuples of (filename, Message object)
1650                """
1651                if self.VERBOSE:
1652                        print "VB: get_message_parts()"
1653
1654                message_parts = list()
1655       
1656                ALTERNATIVE_MULTIPART = False
1657
1658                for part in msg.walk():
1659                        if self.DEBUG:
1660                                print 'TD: Message part: Main-Type: %s' % part.get_content_maintype()
1661                                print 'TD: Message part: Content-Type: %s' % part.get_content_type()
1662
1663                        ## Check content type
1664                        #
1665                        if part.get_content_type() in self.STRIP_CONTENT_TYPES:
1666
1667                                if self.DEBUG:
1668                                        print "TD: A %s attachment named '%s' was skipped" %(part.get_content_type(), part.get_filename())
1669
1670                                continue
1671
1672                        ## Catch some mulitpart execptions
1673                        #
1674                        if part.get_content_type() == 'multipart/alternative':
1675                                ALTERNATIVE_MULTIPART = True
1676                                continue
1677
1678                        ## Skip multipart containers
1679                        #
1680                        if part.get_content_maintype() == 'multipart':
1681                                if self.DEBUG:
1682                                        print "TD: Skipping multipart container"
1683                                continue
1684                       
1685                        ## Check if this is an inline part. It's inline if there is co Cont-Disp header, or if there is one and it says "inline"
1686                        #
1687                        inline = self.inline_part(part)
1688
1689                        ## Drop HTML message
1690                        #
1691                        if ALTERNATIVE_MULTIPART and self.DROP_ALTERNATIVE_HTML_VERSION:
1692                                if part.get_content_type() == 'text/html':
1693                                        if self.DEBUG:
1694                                                print "TD: Skipping alternative HTML message"
1695
1696                                        ALTERNATIVE_MULTIPART = False
1697                                        continue
1698
1699                        ## Inline text parts are where the body is
1700                        #
1701                        if part.get_content_type() == 'text/plain' and inline:
1702                                if self.DEBUG:
1703                                        print 'TD:               Inline body part'
1704
1705                                # Try to decode, if fails then do not decode
1706                                #
1707                                body_text = part.get_payload(decode=1)
1708                                if not body_text:                       
1709                                        body_text = part.get_payload(decode=0)
1710
1711                                format = email.Utils.collapse_rfc2231_value(part.get_param('Format', 'fixed')).lower()
1712                                delsp = email.Utils.collapse_rfc2231_value(part.get_param('DelSp', 'no')).lower()
1713
1714                                if self.REFLOW and not self.VERBATIM_FORMAT and format == 'flowed':
1715                                        body_text = self.reflow(body_text, delsp == 'yes')
1716       
1717                                if self.STRIP_SIGNATURE:
1718                                        body_text = self.strip_signature(body_text)
1719
1720                                if self.STRIP_QUOTES:
1721                                        body_text = self.strip_quotes(body_text)
1722
1723                                if self.INLINE_PROPERTIES:
1724                                        body_text = self.inline_properties(body_text)
1725
1726                                if self.USE_TEXTWRAP:
1727                                        body_text = self.wrap_text(body_text)
1728
1729                                ## Get contents charset (iso-8859-15 if not defined in mail headers)
1730                                #
1731                                charset = part.get_content_charset()
1732                                if not charset:
1733                                        charset = 'iso-8859-15'
1734
1735                                try:
1736                                        ubody_text = unicode(body_text, charset)
1737
1738                                except UnicodeError, detail:
1739                                        ubody_text = unicode(body_text, 'iso-8859-15')
1740
1741                                except LookupError, detail:
1742                                        ubody_text = 'ERROR: Could not find charset: %s, please install' %(charset)
1743
1744                                if self.VERBATIM_FORMAT:
1745                                        message_parts.append('{{{\r\n%s\r\n}}}' %ubody_text)
1746                                else:
1747                                        message_parts.append('%s' %ubody_text)
1748                        else:
1749                                if self.DEBUG:
1750                                        try:
1751                                                print 'TD:               Filename: %s' % part.get_filename()
1752                                        except UnicodeEncodeError, detail:
1753                                                print 'TD:               Filename: Can not be printed due to non-ascii characters'
1754
1755                                ## Convert 7-bit filename to 8 bits value
1756                                #
1757                                filename = self.email_to_unicode(part.get_filename())
1758                                message_parts.append((filename, part))
1759
1760                return message_parts
1761               
1762        def unique_attachment_names(self, message_parts):
1763                """
1764                """
1765                renamed_parts = []
1766                attachment_names = set()
1767
1768                for item in message_parts:
1769                       
1770                        ## If not an attachment, leave it alone
1771                        #
1772                        if not isinstance(item, tuple):
1773                                renamed_parts.append(item)
1774                                continue
1775                               
1776                        (filename, part) = item
1777
1778                        ## If no filename, use a default one
1779                        #
1780                        if not filename:
1781                                filename = 'untitled-part'
1782
1783                                # Guess the extension from the content type, use non strict mode
1784                                # some additional non-standard but commonly used MIME types
1785                                # are also recognized
1786                                #
1787                                ext = mimetypes.guess_extension(part.get_content_type(), False)
1788                                if not ext:
1789                                        ext = '.bin'
1790
1791                                filename = '%s%s' % (filename, ext)
1792
1793                        ## Discard relative paths for windows/unix in attachment names
1794                        #
1795                        #filename = filename.replace('\\', '/').replace(':', '/')
1796                        filename = filename.replace('\\', '_')
1797                        filename = filename.replace('/', '_')
1798
1799                        #
1800                        # We try to normalize the filename to utf-8 NFC if we can.
1801                        # Files uploaded from OS X might be in NFD.
1802                        # Check python version and then try it
1803                        #
1804                        #if sys.version_info[0] > 2 or (sys.version_info[0] == 2 and sys.version_info[1] >= 3):
1805                        #       try:
1806                        #               filename = unicodedata.normalize('NFC', unicode(filename, 'utf-8')).encode('utf-8') 
1807                        #       except TypeError:
1808                        #               pass
1809
1810                        # Make the filename unique for this ticket
1811                        num = 0
1812                        unique_filename = filename
1813                        dummy_filename, ext = os.path.splitext(filename)
1814
1815                        while (unique_filename in attachment_names) or self.attachment_exists(unique_filename):
1816                                num += 1
1817                                unique_filename = "%s-%s%s" % (dummy_filename, num, ext)
1818                               
1819                        if self.DEBUG:
1820                                try:
1821                                        print 'TD: Attachment with filename %s will be saved as %s' % (filename, unique_filename)
1822                                except UnicodeEncodeError, detail:
1823                                        print 'Filename can not be printed due to non-ascii characters'
1824
1825                        attachment_names.add(unique_filename)
1826
1827                        renamed_parts.append((filename, unique_filename, part))
1828       
1829                return renamed_parts
1830                       
1831                       
1832        def attachment_exists(self, filename):
1833
1834                if self.DEBUG:
1835                        s = 'TD: attachment already exists: Id : '
1836                        try:
1837                                print "%s%s, Filename : %s" % (s, self.id, filename)
1838                        except UnicodeEncodeError, detail:
1839                                print "%s%s, Filename : Can not be printed due to non-ascii characters" %(s, self.id)
1840
1841                # We have no valid ticket id
1842                #
1843                if not self.id:
1844                        return False
1845
1846                try:
1847                        if self.system == 'discussion':
1848                                att = attachment.Attachment(self.env, 'discussion', 'ticket/%s'
1849                                  % (self.id,), filename)
1850                        else:
1851                                att = attachment.Attachment(self.env, 'ticket', self.id,
1852                                  filename)
1853                        return True
1854                except attachment.ResourceNotFound:
1855                        return False
1856
1857########## TRAC Ticket Text ###########################################################
1858                       
1859        def body_text(self, message_parts):
1860                body_text = []
1861               
1862                for part in message_parts:
1863                        # Plain text part, append it
1864                        if not isinstance(part, tuple):
1865                                body_text.extend(part.strip().splitlines())
1866                                body_text.append("")
1867                                continue
1868                               
1869                        (original, filename, part) = part
1870                        inline = self.inline_part(part)
1871                       
1872                        if part.get_content_maintype() == 'image' and inline:
1873                                if self.system != 'discussion':
1874                                        body_text.append('[[Image(%s)]]' % filename)
1875                                body_text.append("")
1876                        else:
1877                                if self.system != 'discussion':
1878                                        body_text.append('[attachment:"%s"]' % filename)
1879                                body_text.append("")
1880                               
1881                body_text = '\r\n'.join(body_text)
1882                return body_text
1883
1884        def html_mailto_link(self, subject):
1885                """
1886                This function returns a HTML mailto tag with the ticket id and author email address
1887                """
1888                if not self.author:
1889                        author = self.email_addr
1890                else:   
1891                        author = self.author
1892
1893                # use urllib to escape the chars
1894                #
1895                s = 'mailto:%s?Subject=%s&Cc=%s' %(
1896                       urllib.quote(self.email_addr),
1897                           urllib.quote('Re: #%s: %s' %(self.id, subject)),
1898                           urllib.quote(self.MAILTO_CC)
1899                           )
1900
1901                s = '\r\n{{{\r\n#!html\r\n<a\r\n href="%s">Reply to: %s\r\n</a>\r\n}}}\r\n' %(s, author)
1902                return s
1903
1904########## TRAC notify section ###########################################################
1905
1906        def notify(self, tkt, new=True, modtime=0):
1907                """
1908                A wrapper for the TRAC notify function. So we can use templates
1909                """
1910                if self.DRY_RUN:
1911                                print 'DRY_RUN: self.notify(tkt, True) reporter = %s' %tkt['reporter']
1912                                return
1913                try:
1914                        # create false {abs_}href properties, to trick Notify()
1915                        #
1916                        if not self.VERSION == 0.11:
1917                                self.env.abs_href = Href(self.get_config('project', 'url'))
1918                                self.env.href = Href(self.get_config('project', 'url'))
1919
1920                        tn = TicketNotifyEmail(self.env)
1921
1922                        if self.notify_template:
1923
1924                                if self.VERSION == 0.11:
1925
1926                                        from trac.web.chrome import Chrome
1927
1928                                        if self.notify_template_update and not new:
1929                                                tn.template_name = self.notify_template_update
1930                                        else:
1931                                                tn.template_name = self.notify_template
1932
1933                                        tn.template = Chrome(tn.env).load_template(tn.template_name, method='text')
1934                                               
1935                                else:
1936
1937                                        tn.template_name = self.notify_template;
1938
1939                        tn.notify(tkt, new, modtime)
1940
1941                except Exception, e:
1942                        print 'TD: Failure sending notification on creation of ticket #%s: %s' %(self.id, e)
1943
1944
1945
1946########## Parse Config File  ###########################################################
1947
1948def ReadConfig(file, name):
1949        """
1950        Parse the config file
1951        """
1952        if not os.path.isfile(file):
1953                print 'File %s does not exist' %file
1954                sys.exit(1)
1955
1956        config = trac_config.Configuration(file)
1957
1958        # Use given project name else use defaults
1959        #
1960        if name:
1961                sections = config.sections()
1962                if not name in sections:
1963                        print "Not a valid project name: %s" %name
1964                        print "Valid names: %s" %sections
1965                        sys.exit(1)
1966
1967                project =  dict()
1968                for option, value in  config.options(name):
1969                        project[option] = value
1970
1971        else:
1972                # use some trac internals to get the defaults
1973                #
1974                project = config.parser.defaults()
1975
1976        return project
1977
1978
1979if __name__ == '__main__':
1980        # Default config file
1981        #
1982        configfile = '@email2trac_conf@'
1983        project = ''
1984        component = ''
1985        ticket_prefix = 'default'
1986        dry_run = None
1987        verbose = None
1988
1989        ENABLE_SYSLOG = 0
1990
1991        SHORT_OPT = 'chf:np:t:v'
1992        LONG_OPT  =  ['component=', 'dry-run', 'help', 'file=', 'project=', 'ticket_prefix=', 'verbose']
1993
1994        try:
1995                opts, args = getopt.getopt(sys.argv[1:], SHORT_OPT, LONG_OPT)
1996        except getopt.error,detail:
1997                print __doc__
1998                print detail
1999                sys.exit(1)
2000       
2001        project_name = None
2002        for opt,value in opts:
2003                if opt in [ '-h', '--help']:
2004                        print __doc__
2005                        sys.exit(0)
2006                elif opt in ['-c', '--component']:
2007                        component = value
2008                elif opt in ['-f', '--file']:
2009                        configfile = value
2010                elif opt in ['-n', '--dry-run']:
2011                        dry_run = True
2012                elif opt in ['-p', '--project']:
2013                        project_name = value
2014                elif opt in ['-t', '--ticket_prefix']:
2015                        ticket_prefix = value
2016                elif opt in ['-v', '--version']:
2017                        verbose = True
2018       
2019        settings = ReadConfig(configfile, project_name)
2020        if not settings.has_key('project'):
2021                print __doc__
2022                print 'No Trac project is defined in the email2trac config file.'
2023                sys.exit(1)
2024       
2025        if component:
2026                settings['component'] = component
2027
2028        # The default prefix for ticket values in email2trac.conf
2029        #
2030        settings['ticket_prefix'] = ticket_prefix
2031        settings['dry_run'] = dry_run
2032        settings['verbose'] = verbose
2033       
2034        if settings.has_key('trac_version'):
2035                version = settings['trac_version']
2036        else:
2037                version = trac_default_version
2038
2039
2040        #debug HvB
2041        #print settings
2042
2043        try:
2044                if version == '0.9':
2045                        from trac import attachment
2046                        from trac.env import Environment
2047                        from trac.ticket import Ticket
2048                        from trac.web.href import Href
2049                        from trac import util
2050                        from trac.Notify import TicketNotifyEmail
2051                elif version == '0.10':
2052                        from trac import attachment
2053                        from trac.env import Environment
2054                        from trac.ticket import Ticket
2055                        from trac.web.href import Href
2056                        from trac import util
2057                        #
2058                        # return  util.text.to_unicode(str)
2059                        #
2060                        # see http://projects.edgewall.com/trac/changeset/2799
2061                        from trac.ticket.notification import TicketNotifyEmail
2062                        from trac import config as trac_config
2063                        from trac.core import TracError
2064
2065                elif version == '0.11':
2066                        from trac import attachment
2067                        from trac.env import Environment
2068                        from trac.ticket import Ticket
2069                        from trac.web.href import Href
2070                        from trac import config as trac_config
2071                        from trac import util
2072                        from trac.core import TracError
2073
2074
2075                        #
2076                        # return  util.text.to_unicode(str)
2077                        #
2078                        # see http://projects.edgewall.com/trac/changeset/2799
2079                        from trac.ticket.notification import TicketNotifyEmail
2080                else:
2081                        print 'TRAC version %s is not supported' %version
2082                        sys.exit(1)
2083                       
2084                if settings.has_key('enable_syslog'):
2085                        if SYSLOG_AVAILABLE:
2086                                ENABLE_SYSLOG =  float(settings['enable_syslog'])
2087
2088
2089                # Must be set before environment is created
2090                #
2091                if settings.has_key('python_egg_cache'):
2092                        python_egg_cache = str(settings['python_egg_cache'])
2093                        os.environ['PYTHON_EGG_CACHE'] = python_egg_cache
2094
2095       
2096                if int(settings['debug']) > 0:
2097                        print 'Loading environment', settings['project']
2098
2099                env = Environment(settings['project'], create=0)
2100
2101                tktparser = TicketEmailParser(env, settings, float(version))
2102                tktparser.parse(sys.stdin)
2103
2104        # Catch all errors ans log to SYSLOG if we have enabled this
2105        # else stdout
2106        #
2107        except Exception, error:
2108                if ENABLE_SYSLOG:
2109                        syslog.openlog('email2trac', syslog.LOG_NOWAIT)
2110
2111                        etype, evalue, etb = sys.exc_info()
2112                        for e in traceback.format_exception(etype, evalue, etb):
2113                                syslog.syslog(e)
2114
2115                        syslog.closelog()
2116                else:
2117                        traceback.print_exc()
2118
2119                if m:
2120                        tktparser.save_email_for_debug(m, True)
2121
2122
2123                sys.exit(1)
2124# EOB
Note: See TracBrowser for help on using the repository browser.