source: trunk/email2trac.py.in @ 217

Last change on this file since 217 was 217, checked in by bas, 16 years ago

email2trac.py.in:

  • See Changelog
  • Property svn:executable set to *
  • Property svn:keywords set to Id
File size: 30.4 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
30Changed By: Bas van der Vlies <basv@sara.nl>
31Date      : 13 September 2005
32Descr.    : Added config file and command line options, spam level
33            detection, reply address and mailto option. Unicode support
34
35Changed By: Walter de Jong <walter@sara.nl>
36Descr.    : multipart-message code and trac attachments
37
38
39The scripts reads emails from stdin and inserts directly into a Trac database.
40MIME headers are mapped as follows:
41
42        * From:      => Reporter
43                     => CC (Optional via reply_all option)
44        * Subject:   => Summary
45        * Body       => Description
46        * Component  => Can be set to SPAM via spam_level option
47
48How to use
49----------
50 * Create an config file:
51        [DEFAULT]                      # REQUIRED
52        project      : /data/trac/test # REQUIRED
53        debug        : 1               # OPTIONAL, if set print some DEBUG info
54        spam_level   : 4               # OPTIONAL, if set check for SPAM mail
55        reply_all    : 1               # OPTIONAL, if set then fill in ticket CC field
56        umask        : 022             # OPTIONAL, if set then use this umask for creation of the attachments
57        mailto_link  : 1               # OPTIONAL, if set then [mailto:<>] in description
58        mailto_cc    : basv@sara.nl    # OPTIONAL, use this address as CC in mailto line
59        ticket_update: 1               # OPTIONAL, if set then check if this is an update for a ticket
60        trac_version : 0.9             # OPTIONAL, default is 0.10
61
62        [jouvin]                       # OPTIONAL project declaration, if set both fields necessary
63        project      : /data/trac/jouvin # use -p|--project jouvin. 
64       
65 * default config file is : /etc/email2trac.conf
66
67 * Commandline opions:
68                -h,--help
69                -f,--file  <configuration file>
70                -n,--dry-run
71                -p, --project <project name>
72                -t, --ticket_prefix <name>
73
74SVN Info:
75        $Id: email2trac.py.in 217 2008-08-07 12:27:38Z bas $
76"""
77import os
78import sys
79import string
80import getopt
81import stat
82import time
83import email
84import email.Iterators
85import email.Header
86import re
87import urllib
88import unicodedata
89from stat import *
90import mimetypes
91import traceback
92
93
94# Will fail where unavailable, e.g. Windows
95#
96try:
97    import syslog
98    SYSLOG_AVAILABLE = True
99except ImportError:
100    SYSLOG_AVAILABLE = False
101
102from datetime import tzinfo, timedelta, datetime
103from trac import config as trac_config
104
105# Some global variables
106#
107trac_default_version = '0.10'
108m = None
109
110# A UTC class needed for trac version 0.11, added by
111# tbaschak at ktc dot mb dot ca
112#
113class UTC(tzinfo):
114        """UTC"""
115        ZERO = timedelta(0)
116        HOUR = timedelta(hours=1)
117       
118        def utcoffset(self, dt):
119                return self.ZERO
120               
121        def tzname(self, dt):
122                return "UTC"
123               
124        def dst(self, dt):
125                return self.ZERO
126
127
128class TicketEmailParser(object):
129        env = None
130        comment = '> '
131   
132        def __init__(self, env, parameters, version):
133                self.env = env
134
135                # Database connection
136                #
137                self.db = None
138
139                # Save parameters
140                #
141                self.parameters = parameters
142
143                # Some useful mail constants
144                #
145                self.author = None
146                self.email_addr = None
147                self.email_from = None
148
149                self.VERSION = version
150                self.DRY_RUN = parameters['dry_run']
151
152                self.get_config = self.env.config.get
153
154                if parameters.has_key('umask'):
155                        os.umask(int(parameters['umask'], 8))
156
157                if parameters.has_key('debug'):
158                        self.DEBUG = int(parameters['debug'])
159                else:
160                        self.DEBUG = 0
161
162                if parameters.has_key('mailto_link'):
163                        self.MAILTO = int(parameters['mailto_link'])
164                        if parameters.has_key('mailto_cc'):
165                                self.MAILTO_CC = parameters['mailto_cc']
166                        else:
167                                self.MAILTO_CC = ''
168                else:
169                        self.MAILTO = 0
170
171                if parameters.has_key('spam_level'):
172                        self.SPAM_LEVEL = int(parameters['spam_level'])
173                else:
174                        self.SPAM_LEVEL = 0
175
176                if parameters.has_key('spam_header'):
177                        self.SPAM_HEADER = parameters['spam_header']
178                else:
179                        self.SPAM_HEADER = 'X-Spam-Score'
180
181                if parameters.has_key('email_quote'):
182                        self.EMAIL_QUOTE = str(parameters['email_quote'])
183                else:   
184                        self.EMAIL_QUOTE = '> '
185
186                if parameters.has_key('email_header'):
187                        self.EMAIL_HEADER = int(parameters['email_header'])
188                else:
189                        self.EMAIL_HEADER = 0
190
191                if parameters.has_key('alternate_notify_template'):
192                        self.notify_template = str(parameters['alternate_notify_template'])
193                else:
194                        self.notify_template = None
195
196                if parameters.has_key('reply_all'):
197                        self.REPLY_ALL = int(parameters['reply_all'])
198                else:
199                        self.REPLY_ALL = 0
200
201                if parameters.has_key('ticket_update'):
202                        self.TICKET_UPDATE = int(parameters['ticket_update'])
203                else:
204                        self.TICKET_UPDATE = 0
205
206                if parameters.has_key('drop_spam'):
207                        self.DROP_SPAM = int(parameters['drop_spam'])
208                else:
209                        self.DROP_SPAM = 0
210
211                if parameters.has_key('verbatim_format'):
212                        self.VERBATIM_FORMAT = int(parameters['verbatim_format'])
213                else:
214                        self.VERBATIM_FORMAT = 1
215
216                if parameters.has_key('strip_signature'):
217                        self.STRIP_SIGNATURE = int(parameters['strip_signature'])
218                else:
219                        self.STRIP_SIGNATURE = 0
220
221                if parameters.has_key('strip_quotes'):
222                        self.STRIP_QUOTES = int(parameters['strip_quotes'])
223                else:
224                        self.STRIP_QUOTES = 0
225
226                if parameters.has_key('use_textwrap'):
227                        self.USE_TEXTWRAP = int(parameters['use_textwrap'])
228                else:
229                        self.USE_TEXTWRAP = 0
230
231                if parameters.has_key('python_egg_cache'):
232                        self.python_egg_cache = str(parameters['python_egg_cache'])
233                        os.environ['PYTHON_EGG_CACHE'] = self.python_egg_cache
234
235                # Use OS independend functions
236                #
237                self.TMPDIR = os.path.normcase('/tmp')
238                if parameters.has_key('tmpdir'):
239                        self.TMPDIR = os.path.normcase(str(parameters['tmpdir']))
240
241                if parameters.has_key('ignore_trac_user_settings'):
242                        self.IGNORE_TRAC_USER_SETTINGS = int(parameters['ignore_trac_user_settings'])
243                else:
244                        self.IGNORE_TRAC_USER_SETTINGS = 0
245
246        def spam(self, message):
247                """
248                # X-Spam-Score: *** (3.255) BAYES_50,DNS_FROM_AHBL_RHSBL,HTML_
249                # Note if Spam_level then '*' are included
250                """
251                spam = False
252                if message.has_key(self.SPAM_HEADER):
253                        spam_l = string.split(message[self.SPAM_HEADER])
254
255                        try:
256                                number = spam_l[0].count('*')
257                        except IndexError, detail:
258                                number = 0
259                               
260                        if number >= self.SPAM_LEVEL:
261                                spam = True
262                               
263                # treat virus mails as spam
264                #
265                elif message.has_key('X-Virus-found'):                 
266                        spam = True
267
268                # How to handle SPAM messages
269                #
270                if self.DROP_SPAM and spam:
271                        if self.DEBUG > 2 :
272                                print 'This message is a SPAM. Automatic ticket insertion refused (SPAM level > %d' % self.SPAM_LEVEL
273
274                        return 'drop'   
275
276                elif spam:
277
278                        return 'Spam'   
279
280                else:
281
282                        return False
283
284
285        def blacklisted_from(self):
286                """
287                This function wil check if the email address is in the black list
288                """
289                try:
290                        black_list = self.parameters['black_list']
291                except KeyError, detail:
292                        black_list = 'MAILER-DAEMON@'
293
294                black_list = string.split(black_list)   
295                if not black_list.count('MAILER-DAEMON@'):
296                        black_list.append('MAILER-DAEMON@')
297
298                for entry in black_list:       
299                        entry = entry.strip()
300                        FROM_RE = re.compile(entry, re.VERBOSE|re.IGNORECASE)
301                        result =  FROM_RE.search(self.email_addr)
302                        if result:
303                                return True
304
305                return False
306
307        def email_to_unicode(self, message_str):
308                """
309                Email has 7 bit ASCII code, convert it to unicode with the charset
310        that is encoded in 7-bit ASCII code and encode it as utf-8 so Trac
311                understands it.
312                """
313                results =  email.Header.decode_header(message_str)
314                str = None
315                for text,format in results:
316                        if format:
317                                try:
318                                        temp = unicode(text, format)
319                                except UnicodeError, detail:
320                                        # This always works
321                                        #
322                                        temp = unicode(text, 'iso-8859-15')
323                                except LookupError, detail:
324                                        #text = 'ERROR: Could not find charset: %s, please install' %format
325                                        #temp = unicode(text, 'iso-8859-15')
326                                        temp = message_str
327                                       
328                        else:
329                                temp = string.strip(text)
330                                temp = unicode(text, 'iso-8859-15')
331
332                        if str:
333                                str = '%s %s' %(str, temp)
334                        else:
335                                str = '%s' %temp
336
337                #str = str.encode('utf-8')
338                return str
339
340        def debug_attachments(self, message):
341                n = 0
342                for part in message.walk():
343                        if part.get_content_maintype() == 'multipart':      # multipart/* is just a container
344                                print 'TD: multipart container'
345                                continue
346
347                        n = n + 1
348                        print 'TD: part%d: Content-Type: %s' % (n, part.get_content_type())
349                        print 'TD: part%d: filename: %s' % (n, part.get_filename())
350
351                        if part.is_multipart():
352                                print 'TD: this part is multipart'
353                                payload = part.get_payload(decode=1)
354                                print 'TD: payload:', payload
355                        else:
356                                print 'TD: this part is not multipart'
357
358                        file = 'part%d' %n
359                        part_file = os.path.join(self.TMPDIR, file)
360                        #part_file = '/var/tmp/part%d' % n
361                        print 'TD: writing part%d (%s)' % (n,part_file)
362                        fx = open(part_file, 'wb')
363                        text = part.get_payload(decode=1)
364                        if not text:
365                                text = '(None)'
366                        fx.write(text)
367                        fx.close()
368                        try:
369                                os.chmod(part_file,S_IRWXU|S_IRWXG|S_IRWXO)
370                        except OSError:
371                                pass
372
373        def email_header_txt(self, m):
374                """
375                Display To and CC addresses in description field
376                """
377                str = ''
378                #if m['To'] and len(m['To']) > 0 and m['To'] != 'hic@sara.nl':
379                if m['To'] and len(m['To']) > 0:
380                        str = "'''To:''' %s\r\n" %(m['To'])
381                if m['Cc'] and len(m['Cc']) > 0:
382                        str = "%s'''Cc:''' %s\r\n" % (str, m['Cc'])
383
384                return  self.email_to_unicode(str)
385
386
387        def set_owner(self, ticket):
388                """
389                Select default owner for ticket component
390                """
391                #### return self.get_config('ticket', 'default_component')
392                cursor = self.db.cursor()
393                sql = "SELECT owner FROM component WHERE name='%s'" % ticket['component']
394                cursor.execute(sql)
395                try:
396                        ticket['owner'] = cursor.fetchone()[0]
397                except TypeError, detail:
398                        ticket['owner'] = None
399
400        def get_sender_info(self, message):
401                """
402                Get the default author name and email address from the message
403                """
404
405                self.email_from = self.email_to_unicode(message['from'])
406                self.author, self.email_addr  = email.Utils.parseaddr(self.email_from)
407
408                # Maybe for later user
409                #self.email_from =  self.email_to_unicode(self.email_addr)
410
411
412                if self.IGNORE_TRAC_USER_SETTINGS:
413                        return
414
415                # Is this a registered user, use email address as search key:
416                # result:
417                #   u : login name
418                #   n : Name that the user has set in the settings tab
419                #   e : email address that the user has set in the settings tab
420                #
421                users = [ (u,n,e) for (u, n, e) in self.env.get_known_users(self.db)
422                                if e == self.email_addr ]
423
424                if len(users) == 1:
425                        self.email_from = users[0][0]
426
427        def set_reply_fields(self, ticket, message):
428                """
429                Set all the right fields for a new ticket
430                """
431                ticket['reporter'] = self.email_from
432
433                # Put all CC-addresses in ticket CC field
434                #
435                if self.REPLY_ALL:
436                        #tos = message.get_all('to', [])
437                        ccs = message.get_all('cc', [])
438
439                        addrs = email.Utils.getaddresses(ccs)
440                        if not addrs:
441                                return
442
443                        # Remove reporter email address if notification is
444                        # on
445                        #
446                        if self.notification:
447                                try:
448                                        addrs.remove((self.author, self.email_addr))
449                                except ValueError, detail:
450                                        pass
451
452                        for name,mail in addrs:
453                                try:
454                                        mail_list = '%s, %s' %(mail_list, mail)
455                                except:
456                                        mail_list = mail
457
458                        if mail_list:
459                                ticket['cc'] = self.email_to_unicode(mail_list)
460
461        def save_email_for_debug(self, message, tempfile=False):
462                if tempfile:
463                        import tempfile
464                        msg_file = tempfile.mktemp('.email2trac')
465                else:
466                        #msg_file = '/var/tmp/msg.txt'
467                        msg_file = os.path.join(self.TMPDIR, 'msg.txt')
468
469                print 'TD: saving email to %s' % msg_file
470                fx = open(msg_file, 'wb')
471                fx.write('%s' % message)
472                fx.close()
473                try:
474                        os.chmod(msg_file,S_IRWXU|S_IRWXG|S_IRWXO)
475                except OSError:
476                        pass
477
478        def str_to_dict(self, str):
479                """
480                Transfrom a str of the form [<key>=<value>]+ to dict[<key>] = <value>
481                """
482                # Skip the last ':' character
483                #
484                fields = string.split(str[:-1], ',')
485
486                result = dict()
487                for field in fields:
488                        try:
489                                index, value = string.split(field,'=')
490
491                                # We can not change the description of a ticket via the subject
492                                # line. The description is the body of the email
493                                #
494                                if index.lower() in ['description']:
495                                        continue
496
497                                if value:
498                                        result[index.lower()] = value
499
500                        except ValueError:
501                                pass
502
503                return result
504
505        def update_ticket_fields(self, ticket, user_dict, use_default=None):
506                """
507                This will update the ticket fields. It will check if the
508                given fields are known and if the right values are specified
509                It will only update the ticket field value:
510                        - If the field is known
511                        - If the value supplied is valid for the ticket field.
512                          If not then there are two options:
513                           1) Skip the value (use_default=None)
514                           2) Set default value for field (use_default=1)
515                """
516
517                # Build a system dictionary from the ticket fields
518                # with field as index and option as value
519                #
520                sys_dict = dict()
521                for field in ticket.fields:
522                        try:
523                                sys_dict[field['name']] = field['options']
524
525                        except KeyError:
526                                sys_dict[field['name']] = None
527                                pass
528
529                # Check user supplied fields an compare them with the
530                # system one's
531                #
532                for field,value in user_dict.items():
533                        if self.DEBUG >= 10:
534                                print  'user_field\t %s = %s' %(field,value)
535
536                        if sys_dict.has_key(field):
537
538                                # Check if value is an allowed system option, if TypeError then
539                                # every value is allowed
540                                #
541                                try:
542                                        if value in sys_dict[field]:
543                                                ticket[field] = value
544                                        else:
545                                                # Must we set a default if value is not allowed
546                                                #
547                                                if use_default:
548                                                        value = self.get_config('ticket', 'default_%s' %(field) )
549                                                        ticket[field] = value
550
551                                except TypeError:
552                                        ticket[field] = value
553
554                                if self.DEBUG >= 10:
555                                        print  'ticket_field\t %s = %s' %(field,  ticket[field])
556                                       
557        def ticket_update(self, m, spam):
558                """
559                If the current email is a reply to an existing ticket, this function
560                will append the contents of this email to that ticket, instead of
561                creating a new one.
562                """
563
564                if not m['Subject']:
565                        return False
566                else:
567                        subject  = self.email_to_unicode(m['Subject'])
568
569                # [hic] #1529: Re: LRZ
570                # [hic] #1529?owner=bas,priority=medium: Re: LRZ
571                #
572                TICKET_RE = re.compile(r"""
573                                        (?P<ticketnr>[#][0-9]+:)
574                                        |(?P<ticketnr_fields>[#][\d]+\?.*?:)
575                                        """, re.VERBOSE)
576
577                result =  TICKET_RE.search(subject)
578                if not result:
579                        return False
580
581                # Must we update ticket fields
582                #
583                update_tkt_fields = dict()
584                try:
585                        nr, keywords = string.split(result.group('ticketnr_fields'), '?')
586                        update_tkt_fields = self.str_to_dict(keywords)
587
588                        # Strip '#'
589                        #
590                        ticket_id = int(nr[1:])
591
592                except AttributeError:
593                        # Strip '#' and ':'
594                        #
595                        nr = result.group('ticketnr')
596                        ticket_id = int(nr[1:-1])
597
598
599                # When is the change committed
600                #
601                #
602                if self.VERSION == 0.11:
603                        utc = UTC()
604                        when = datetime.now(utc)
605                else:
606                        when = int(time.time())
607
608                try:
609                        tkt = Ticket(self.env, ticket_id, self.db)
610                except util.TracError, detail:
611                        return False
612
613                # Must we update some ticket fields properties
614                #
615                if update_tkt_fields:
616                        self.update_ticket_fields(tkt, update_tkt_fields)
617
618                body_text = self.get_body_text(m)
619
620                # reopen the ticket if is was closed
621                #
622                if tkt['status'] in ['closed']:
623                        tkt['status'] = 'reopened'
624                        tkt['resolution'] = ''
625
626                if self.EMAIL_HEADER:
627                        head = self.email_header_txt(m)
628                        body_text = u"%s\r\n%s" %(head, body_text)
629
630                tkt.save_changes(self.author, body_text, when)
631                tkt['id'] = ticket_id
632
633                if self.VERSION  == 0.9:
634                        str = self.attachments(m, tkt, True)
635                else:
636                        str = self.attachments(m, tkt)
637
638                if self.notification and not spam:
639                        self.notify(tkt, False, when)
640
641                return True
642
643        def set_ticket_fields(self, ticket):
644                """
645                set the ticket fields to value specified
646                        - /etc/email2trac.conf with <prefix>_<field>
647                        - trac default values, trac.ini
648                """
649                user_dict = dict()
650
651                for field in ticket.fields:
652
653                        name = field['name']
654
655                        # skip some fields like resolution
656                        #
657                        if name in [ 'resolution' ]:
658                                continue
659
660                        # default trac value
661                        #
662                        value = self.get_config('ticket', 'default_%s' %(name) )
663                        if self.DEBUG > 10:
664                                print 'trac.ini name %s = %s' %(name, value)
665
666                        prefix = self.parameters['ticket_prefix']
667                        try:
668                                value = self.parameters['%s_%s' %(prefix, name)]
669                                if self.DEBUG > 10:
670                                        print 'email2trac.conf %s = %s ' %(name, value)
671
672                        except KeyError, detail:
673                                pass
674               
675                        if self.DEBUG:
676                                print 'user_dict[%s] = %s' %(name, value)
677
678                        user_dict[name] = value
679
680                self.update_ticket_fields(ticket, user_dict, use_default=1)
681
682                # Set status ticket
683                #`
684                ticket['status'] = 'new'
685
686
687
688        def new_ticket(self, msg, spam):
689                """
690                Create a new ticket
691                """
692                tkt = Ticket(self.env)
693
694                self.set_ticket_fields(tkt)
695
696                # Some defaults
697                #
698                #tkt['status'] = 'new'
699                #tkt['milestone'] = self.get_config('ticket', 'default_milestone')
700                #tkt['priority'] = self.get_config('ticket', 'default_priority')
701                #tkt['severity'] = self.get_config('ticket', 'default_severity')
702                #tkt['version'] = self.get_config('ticket', 'default_version')
703                #tkt['type'] = self.get_config('ticket', 'default_type')
704
705                # Old style setting for component, will be removed
706                #
707                if spam:
708                        tkt['component'] = 'Spam'
709
710                elif self.parameters.has_key('component'):
711                        tkt['component'] = self.parameters['component']
712
713                if not msg['Subject']:
714                        tkt['summary'] = u'(No subject)'
715                else:
716                        tkt['summary'] = self.email_to_unicode(msg['Subject'])
717
718
719                self.set_reply_fields(tkt, msg)
720
721                # produce e-mail like header
722                #
723                head = ''
724                if self.EMAIL_HEADER > 0:
725                        head = self.email_header_txt(msg)
726                       
727                body_text = self.get_body_text(msg)
728
729                tkt['description'] = '%s\r\n%s' \
730                        %(head, body_text)
731
732                #when = int(time.time())
733                #
734                utc = UTC()
735                when = datetime.now(utc)
736
737                if self.DRY_RUN:
738                        ticket_id = 'DRY_RUN'
739                else:
740                        ticket_id = tkt.insert()
741                       
742                tkt['id'] = ticket_id
743
744                changed = False
745                comment = ''
746
747                # Rewrite the description if we have mailto enabled
748                #
749                if self.MAILTO:
750                        changed = True
751                        comment = u'\nadded mailto line\n'
752                        #mailto = self.html_mailto_link(tkt['summary'], ticket_id, body_text)
753                        mailto = self.html_mailto_link( m['Subject'], ticket_id, body_text)
754                        tkt['description'] = u'%s\r\n%s%s\r\n' \
755                                %(head, mailto, body_text)
756
757                str =  self.attachments(msg, tkt)
758                if str:
759                        changed = True
760                        comment = '%s\n%s\n' %(comment, str)
761
762                if changed:
763                        if self.DRY_RUN:
764                                print 'DRY_RUN: tkt.save_changes(self.author, comment)'
765                        else:
766                                tkt.save_changes(self.author, comment)
767                                #print tkt.get_changelog(self.db, when)
768
769                if self.notification:
770                        if self.DRY_RUN:
771                                print 'DRY_RUN: self.notify(tkt, True)'
772                        else:
773                                if not spam:
774                                        self.notify(tkt, True)
775                                #self.notify(tkt, False)
776
777        def parse(self, fp):
778                global m
779
780                m = email.message_from_file(fp)
781                if not m:
782                        return
783
784                if self.DEBUG > 1:        # save the entire e-mail message text
785                        self.save_email_for_debug(m)
786                        self.debug_attachments(m)
787
788                self.db = self.env.get_db_cnx()
789                self.get_sender_info(m)
790
791                if self.blacklisted_from():
792                        if self.DEBUG > 1 :
793                                print 'Message rejected : From: in blacklist'
794                        return False
795
796                # If drop the message
797                #
798                if self.spam(m) == 'drop':
799                        return False
800
801                elif self.spam(m) == 'spam':
802                        spam_msg = True
803
804                else:
805                        spam_msg = False
806
807                if self.get_config('notification', 'smtp_enabled') in ['true']:
808                        self.notification = 1
809                else:
810                        self.notification = 0
811
812                # Must we update existing tickets
813                #
814                if self.TICKET_UPDATE > 0:
815                        if self.ticket_update(m, spam_msg):
816                                return True
817
818                self.new_ticket(m, spam_msg)
819
820        def strip_signature(self, text):
821                """
822                Strip signature from message, inspired by Mailman software
823                """
824                body = []
825                for line in text.splitlines():
826                        if line == '-- ':
827                                break
828                        body.append(line)
829
830                return ('\n'.join(body))
831
832        def strip_quotes(self, text):
833                """
834                Strip quotes from message by Nicolas Mendoza
835                """
836                body = []
837                for line in text.splitlines():
838                        if line.startswith(self.EMAIL_QUOTE):
839                                continue
840                        body.append(line)
841
842                return ('\n'.join(body))
843
844        def wrap_text(self, text, replace_whitespace = False):
845                """
846                Will break a lines longer then given length into several small
847                lines of size given length
848                """
849                import textwrap
850
851                LINESEPARATOR = '\n'
852                reformat = ''
853
854                for s in text.split(LINESEPARATOR):
855                        tmp = textwrap.fill(s,self.USE_TEXTWRAP)
856                        if tmp:
857                                reformat = '%s\n%s' %(reformat,tmp)
858                        else:
859                                reformat = '%s\n' %reformat
860
861                return reformat
862
863                # Python2.4 and higher
864                #
865                #return LINESEPARATOR.join(textwrap.fill(s,width) for s in str.split(LINESEPARATOR))
866                #
867
868
869        def get_body_text(self, msg):
870                """
871                put the message text in the ticket description or in the changes field.
872                message text can be plain text or html or something else
873                """
874                has_description = 0
875                encoding = True
876                ubody_text = u'No plain text message'
877                for part in msg.walk():
878
879                        # 'multipart/*' is a container for multipart messages
880                        #
881                        if part.get_content_maintype() == 'multipart':
882                                continue
883
884                        if part.get_content_type() == 'text/plain':
885                                # Try to decode, if fails then do not decode
886                                #
887                                body_text = part.get_payload(decode=1)
888                                if not body_text:                       
889                                        body_text = part.get_payload(decode=0)
890       
891                                if self.STRIP_SIGNATURE:
892                                        body_text = self.strip_signature(body_text)
893
894                                if self.STRIP_QUOTES:
895                                        body_text = self.strip_quotes(body_text)
896
897                                if self.USE_TEXTWRAP:
898                                        body_text = self.wrap_text(body_text)
899
900                                # Get contents charset (iso-8859-15 if not defined in mail headers)
901                                #
902                                charset = part.get_content_charset()
903                                if not charset:
904                                        charset = 'iso-8859-15'
905
906                                try:
907                                        ubody_text = unicode(body_text, charset)
908
909                                except UnicodeError, detail:
910                                        ubody_text = unicode(body_text, 'iso-8859-15')
911
912                                except LookupError, detail:
913                                        ubody_text = 'ERROR: Could not find charset: %s, please install' %(charset)
914
915                        elif part.get_content_type() == 'text/html':
916                                ubody_text = '(see attachment for HTML mail message)'
917
918                        else:
919                                ubody_text = '(see attachment for message)'
920
921                        has_description = 1
922                        break           # we have the description, so break
923
924                if not has_description:
925                        ubody_text = '(see attachment for message)'
926
927                # A patch so that the web-interface will not update the description
928                # field of a ticket
929                #
930                ubody_text = ('\r\n'.join(ubody_text.splitlines()))
931
932                #  If we can unicode it try to encode it for trac
933                #  else we a lot of garbage
934                #
935                #if encoding:
936                #       ubody_text = ubody_text.encode('utf-8')
937
938                if self.VERBATIM_FORMAT:
939                        ubody_text = '{{{\r\n%s\r\n}}}' %ubody_text
940                else:
941                        ubody_text = '%s' %ubody_text
942
943                return ubody_text
944
945        def notify(self, tkt , new=True, modtime=0):
946                """
947                A wrapper for the TRAC notify function. So we can use templates
948                """
949                try:
950                        # create false {abs_}href properties, to trick Notify()
951                        #
952                        if not self.VERSION == 0.11:
953                                self.env.abs_href = Href(self.get_config('project', 'url'))
954                                self.env.href = Href(self.get_config('project', 'url'))
955
956                        tn = TicketNotifyEmail(self.env)
957
958                        if self.notify_template:
959                                tn.template_name = self.notify_template;
960
961                        tn.notify(tkt, new, modtime)
962
963                except Exception, e:
964                        print 'TD: Failure sending notification on creation of ticket #%s: %s' %(tkt['id'], e)
965
966        def html_mailto_link(self, subject, id, body):
967                if not self.author:
968                        author = self.email_addr
969                else:   
970                        author = self.author
971
972                # Must find a fix
973                #
974                #arr = string.split(body, '\n')
975                #arr = map(self.mail_line, arr)
976                #body = string.join(arr, '\n')
977                #body = '%s wrote:\n%s' %(author, body)
978
979                # Temporary fix
980                #
981                str = 'mailto:%s?Subject=%s&Cc=%s' %(
982                       urllib.quote(self.email_addr),
983                           urllib.quote('Re: #%s: %s' %(id, subject)),
984                           urllib.quote(self.MAILTO_CC)
985                           )
986
987                str = '\r\n{{{\r\n#!html\r\n<a\r\n href="%s">Reply to: %s\r\n</a>\r\n}}}\r\n' %(str, author)
988                return str
989
990        def attachments(self, message, ticket, update=False):
991                '''
992                save any attachments as files in the ticket's directory
993                '''
994                count = 0
995                first = 0
996                number = 0
997
998                # Get Maxium attachment size
999                #
1000                max_size = int(self.get_config('attachment', 'max_size'))
1001                status   = ''
1002
1003                for part in message.walk():
1004                        if part.get_content_maintype() == 'multipart':          # multipart/* is just a container
1005                                continue
1006
1007                        if not first:                                                                           # first content is the message
1008                                first = 1
1009                                if part.get_content_type() == 'text/plain':             # if first is text, is was already put in the description
1010                                        continue
1011
1012                        filename = part.get_filename()
1013                        if not filename:
1014                                number = number + 1
1015                                filename = 'part%04d' % number
1016
1017                                ext = mimetypes.guess_extension(part.get_content_type())
1018                                if not ext:
1019                                        ext = '.bin'
1020
1021                                filename = '%s%s' % (filename, ext)
1022                        else:
1023                                filename = self.email_to_unicode(filename)
1024
1025                        # From the trac code
1026                        #
1027                        filename = filename.replace('\\', '/').replace(':', '/')
1028                        filename = os.path.basename(filename)
1029
1030                        # We try to normalize the filename to utf-8 NFC if we can.
1031                        # Files uploaded from OS X might be in NFD.
1032                        # Check python version and then try it
1033                        #
1034                        if sys.version_info[0] > 2 or (sys.version_info[0] == 2 and sys.version_info[1] >= 3):
1035                                try:
1036                                        filename = unicodedata.normalize('NFC', unicode(filename, 'utf-8')).encode('utf-8') 
1037                                except TypeError:
1038                                        pass
1039
1040                        url_filename = urllib.quote(filename)
1041                        #
1042                        # Must be tuneables HvB
1043                        #
1044                        path, fd =  util.create_unique_file(os.path.join(self.TMPDIR, url_filename))
1045                        text = part.get_payload(decode=1)
1046                        if not text:
1047                                text = '(None)'
1048                        fd.write(text)
1049                        fd.close()
1050
1051                        # get the file_size
1052                        #
1053                        stats = os.lstat(path)
1054                        file_size = stats[stat.ST_SIZE]
1055
1056                        # Check if the attachment size is allowed
1057                        #
1058                        if (max_size != -1) and (file_size > max_size):
1059                                status = '%s\nFile %s is larger then allowed attachment size (%d > %d)\n\n' \
1060                                        %(status, filename, file_size, max_size)
1061
1062                                os.unlink(path)
1063                                continue
1064                        else:
1065                                count = count + 1
1066                                       
1067                        # Insert the attachment
1068                        #
1069                        fd = open(path)
1070                        att = attachment.Attachment(self.env, 'ticket', ticket['id'])
1071
1072                        # This will break the ticket_update system, the body_text is vaporized
1073                        # ;-(
1074                        #
1075                        if not update:
1076                                att.author = self.author
1077                                att.description = self.email_to_unicode('Added by email2trac')
1078
1079                        att.insert(url_filename, fd, file_size)
1080                        #except  util.TracError, detail:
1081                        #       print detail
1082
1083                        # Remove the created temporary filename
1084                        #
1085                        fd.close()
1086                        os.unlink(path)
1087
1088                # Return how many attachments
1089                #
1090                status = 'This message has %d attachment(s)\n%s' %(count, status)
1091                return status
1092
1093
1094def mkdir_p(dir, mode):
1095        '''do a mkdir -p'''
1096
1097        arr = string.split(dir, '/')
1098        path = ''
1099        for part in arr:
1100                path = '%s/%s' % (path, part)
1101                try:
1102                        stats = os.stat(path)
1103                except OSError:
1104                        os.mkdir(path, mode)
1105
1106def ReadConfig(file, name):
1107        """
1108        Parse the config file
1109        """
1110        if not os.path.isfile(file):
1111                print 'File %s does not exist' %file
1112                sys.exit(1)
1113
1114        config = trac_config.Configuration(file)
1115
1116        # Use given project name else use defaults
1117        #
1118        if name:
1119                sections = config.sections()
1120                if not name in sections:
1121                        print "Not a valid project name: %s" %name
1122                        print "Valid names: %s" %sections
1123                        sys.exit(1)
1124
1125                project =  dict()
1126                for option, value in  config.options(name):
1127                        project[option] = value
1128
1129        else:
1130                # use some trac internales to get the defaults
1131                #
1132                project = config.parser.defaults()
1133
1134        return project
1135
1136
1137if __name__ == '__main__':
1138        # Default config file
1139        #
1140        configfile = '@email2trac_conf@'
1141        project = ''
1142        component = ''
1143        ticket_prefix = 'default'
1144        dry_run = None
1145
1146        ENABLE_SYSLOG = 0
1147
1148
1149        SHORT_OPT = 'chf:np:t:'
1150        LONG_OPT  =  ['component=', 'dry-run', 'help', 'file=', 'project=', 'ticket_prefix=']
1151
1152        try:
1153                opts, args = getopt.getopt(sys.argv[1:], SHORT_OPT, LONG_OPT)
1154        except getopt.error,detail:
1155                print __doc__
1156                print detail
1157                sys.exit(1)
1158       
1159        project_name = None
1160        for opt,value in opts:
1161                if opt in [ '-h', '--help']:
1162                        print __doc__
1163                        sys.exit(0)
1164                elif opt in ['-c', '--component']:
1165                        component = value
1166                elif opt in ['-f', '--file']:
1167                        configfile = value
1168                elif opt in ['-n', '--dry-run']:
1169                        dry_run = True
1170                elif opt in ['-p', '--project']:
1171                        project_name = value
1172                elif opt in ['-t', '--ticket_prefix']:
1173                        ticket_prefix = value
1174       
1175        settings = ReadConfig(configfile, project_name)
1176        if not settings.has_key('project'):
1177                print __doc__
1178                print 'No Trac project is defined in the email2trac config file.'
1179                sys.exit(1)
1180       
1181        if component:
1182                settings['component'] = component
1183
1184        # The default prefix for ticket values in email2trac.conf
1185        #
1186        settings['ticket_prefix'] = ticket_prefix
1187        settings['dry_run'] = dry_run
1188       
1189        if settings.has_key('trac_version'):
1190                version = settings['trac_version']
1191        else:
1192                version = trac_default_version
1193
1194
1195        #debug HvB
1196        #print settings
1197
1198        try:
1199                if version == '0.9':
1200                        from trac import attachment
1201                        from trac.env import Environment
1202                        from trac.ticket import Ticket
1203                        from trac.web.href import Href
1204                        from trac import util
1205                        from trac.Notify import TicketNotifyEmail
1206                elif version == '0.10':
1207                        from trac import attachment
1208                        from trac.env import Environment
1209                        from trac.ticket import Ticket
1210                        from trac.web.href import Href
1211                        from trac import util
1212                        #
1213                        # return  util.text.to_unicode(str)
1214                        #
1215                        # see http://projects.edgewall.com/trac/changeset/2799
1216                        from trac.ticket.notification import TicketNotifyEmail
1217                        from trac import config as trac_config
1218                elif version == '0.11':
1219                        from trac import attachment
1220                        from trac.env import Environment
1221                        from trac.ticket import Ticket
1222                        from trac.web.href import Href
1223                        from trac import config as trac_config
1224                        from trac import util
1225                        #
1226                        # return  util.text.to_unicode(str)
1227                        #
1228                        # see http://projects.edgewall.com/trac/changeset/2799
1229                        from trac.ticket.notification import TicketNotifyEmail
1230                else:
1231                        print 'TRAC version %s is not supported' %version
1232                        sys.exit(1)
1233                       
1234                if settings.has_key('enable_syslog'):
1235                        if SYSLOG_AVAILABLE:
1236                                ENABLE_SYSLOG =  float(settings['enable_syslog'])
1237
1238                env = Environment(settings['project'], create=0)
1239                tktparser = TicketEmailParser(env, settings, float(version))
1240                tktparser.parse(sys.stdin)
1241
1242        # Catch all errors ans log to SYSLOG if we have enabled this
1243        # else stdout
1244        #
1245        except Exception, error:
1246                if ENABLE_SYSLOG:
1247                        syslog.openlog('email2trac', syslog.LOG_NOWAIT)
1248
1249                        etype, evalue, etb = sys.exc_info()
1250                        for e in traceback.format_exception(etype, evalue, etb):
1251                                syslog.syslog(e)
1252
1253                        syslog.closelog()
1254                else:
1255                        traceback.print_exc()
1256
1257                if m:
1258                        tktparser.save_email_for_debug(m, True)
1259
1260# EOB
Note: See TracBrowser for help on using the repository browser.