source: trunk/email2trac.py.in @ 450

Last change on this file since 450 was 450, checked in by bas, 13 years ago

Some more variables ported to UserDict?

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