source: trunk/email2trac.py.in @ 539

Last change on this file since 539 was 539, checked in by bas, 10 years ago

fixed check permission problem when PrivateTicketsPlugin? is installed, closes #262

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