source: trunk/email2trac.py.in @ 530

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

updated fix for ticket update fields

  • Property svn:executable set to *
  • Property svn:keywords set to Id
File size: 79.9 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 530 2011-06-30 09:46: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')
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")
692
693        if self.parameters.ticket_permission_system in ['trac']:
694
695            perm = PermissionSystem(self.env)
696            if perm.check_permission(action, self.author):
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        sys_field_list = list()
736
737        for field in ticket.fields:
738
739            sys_field_list.append(field['name'])
740
741            try:
742                sys_dict[field['name']] = field['options']
743
744            except KeyError:
745                #sys_dict[field['name']] = None
746                pass
747
748        ## Check user supplied fields an compare them with the
749        #  system one's
750        #
751        for field,value in user_dict.items():
752
753            if self.parameters.debug:
754                s = 'user_field\t %s = %s' %(field,value)
755                self.print_unicode(s)
756
757            if not field in sys_field_list: 
758                self.logger.debug('%s is not a valid field for tickets' %(field))
759                continue
760
761            ## To prevent mail loop
762            #
763            if field == 'cc':
764
765                cc_list = user_dict['cc'].split(',')
766
767                if self.trac_smtp_from in cc_list:
768                    self.logger.debug('MAIL LOOP: %s is not allowed as CC address' %(self.trac_smtp_from))
769
770                    cc_list.remove(self.trac_smtp_from)
771
772                value = ','.join(cc_list)
773               
774
775            ## Check if every value is allowed for this field
776            #
777            if sys_dict.has_key(field):
778
779                if value in sys_dict[field]:
780                    ticket[field] = value
781                else:
782                    ## Must we set a default if value is not allowed
783                    #
784                    if new:
785                        value = self.get_config('ticket', 'default_%s' %(field) )
786
787            else:
788                ## Only set if we have a value
789                #
790                #if value:
791                #   ticket[field] = value
792                ticket[field] = value
793
794            if self.parameters.debug:
795                s = 'ticket_field\t %s = %s' %(field,  ticket[field])
796                self.print_unicode(s)
797
798    def ticket_update(self, m, id, spam):
799        """
800        If the current email is a reply to an existing ticket, this function
801        will append the contents of this email to that ticket, instead of
802        creating a new one.
803        """
804        self.logger.debug("function ticket_update")
805
806        if not self.parameters.ticket_update:
807            self.logger.debug("ticket_update disabled")
808            return False
809
810        ## Must we update ticket fields
811        #
812        update_fields = dict()
813        try:
814            id, keywords = string.split(id, '?')
815
816            update_fields = self.str_to_dict(keywords)
817
818            ## Strip '#'
819            #
820            self.id = int(id[1:])
821
822        except ValueError:
823
824            ## Strip '#'
825            #
826            self.id = int(id[1:])
827
828        self.logger.debug("ticket_update id %s" %id)
829
830        ## When is the change committed
831        #
832        if self.VERSION < 0.11:
833            when = int(time.time())
834        else:
835            when = datetime.now(util.datefmt.utc)
836
837        try:
838            tkt = Ticket(self.env, self.id, self.db)
839
840        except util.TracError, detail:
841
842            ## Not a valid ticket
843            #
844            self.id = None
845            return False
846
847        ## Check the permission of the reporter
848        #
849        if self.parameters.ticket_permission_system:
850            if not self.check_permission(tkt, 'TICKET_APPEND'):
851                self.logger.info('Reporter: %s has no permission to add comments or attachments to tickets' %self.author)
852                return False
853
854        ## How many changes has this ticket
855        #
856        # cnum = len(tkt.get_changelog())
857        grouped = TicketModule(self.env).grouped_changelog_entries(tkt, self.db)
858        cnum = sum(1 for e in grouped) + 1
859
860
861        ## reopen the ticket if it is was closed
862        #  We must use the ticket workflow framework
863        #
864        if self.parameters.email_triggers_workflow and (self.VERSION >= 0.11):
865
866            self.logger.debug('Workflow ticket update fields: ')
867
868            from trac.ticket.default_workflow import ConfigurableTicketWorkflow
869            from trac.test import Mock, MockPerm
870
871            req = Mock(authname=self.author, perm=MockPerm(), args={})
872            try:
873                workflow = self.parameters['workflow_%s' %tkt['status']]
874            except KeyError:
875                ##
876                # fallback for compability (Will be deprecated)
877                # workflow can be none.
878                #
879                workflow = None
880                if tkt['status'] in ['closed']:
881                    workflow = self.parameters.workflow
882
883            controller = ConfigurableTicketWorkflow(self.env)
884            #print controller.actions
885            #print controller.actions.keys()
886            #print controller.get_ticket_actions(req, tkt)
887            #print controller.actions[workflow]
888            #print controller.actions[workflow]['permissions'] is a list
889
890            if workflow:
891
892                if self.parameters.ticket_permission_system:
893
894                    if self.check_permission(tkt, controller.actions[workflow]['permissions'][0]):
895                        fields = controller.get_ticket_changes(req, tkt, workflow)
896                    else:
897                        fields = dict()
898                        self.logger.info('Reporter: %s has no permission to trigger workflow' %self.author)
899
900                else:
901                    fields = controller.get_ticket_changes(req, tkt, workflow)
902
903                for key in fields.keys():
904                    self.logger.debug('\t %s : %s' %(key, fields[key]))
905                    tkt[key] = fields[key]
906
907            else:
908
909                if tkt['status'] in ['closed']:
910                    tkt['status'] = 'reopened'
911                    tkt['resolution'] = ''
912
913        ## Old pre 0.11 situation
914        #
915        elif self.parameters.email_triggers_workflow:
916
917            self.logger.debug('email triggers workflow pre trac 0.11')
918
919            if tkt['status'] in ['closed']:
920                tkt['status'] = 'reopened'
921                tkt['resolution'] = ''
922
923        else:
924            self.logger.debug('email triggers workflow disabled')
925
926        ## Must we update some ticket fields properties via subject line
927        #
928        if update_fields:
929            self.update_ticket_fields(tkt, update_fields)
930
931        message_parts = self.get_message_parts(m)
932        message_parts = self.unique_attachment_names(message_parts)
933
934        ## Must we update some ticket fields properties via body_text
935        #
936        if self.properties:
937                self.update_ticket_fields(tkt, self.properties)
938
939        if self.parameters.email_header:
940            message_parts.insert(0, self.email_header_txt(m))
941
942        body_text = self.get_body_text(message_parts)
943
944        error_with_attachments = self.attach_attachments(message_parts)
945
946        if body_text.strip() or update_fields or self.properties:
947            if self.parameters.dry_run:
948                print 'DRY_RUN: tkt.save_changes(self.author, body_text, ticket_change_number) ', self.author, cnum
949            else:
950                if error_with_attachments:
951                    body_text = '%s\\%s' %(error_with_attachments, body_text)
952                self.logger.debug('tkt.save_changes(%s, %d)' %(self.author, cnum))
953                tkt.save_changes(self.author, body_text, when, None, str(cnum))
954           
955
956        if not spam:
957            self.notify(tkt, False, when)
958
959        return True
960
961    def set_ticket_fields(self, ticket):
962        """
963        set the ticket fields to value specified
964            - /etc/email2trac.conf with <prefix>_<field>
965            - trac default values, trac.ini
966        """
967        self.logger.debug('function set_ticket_fields')
968
969        user_dict = dict()
970
971        for field in ticket.fields:
972
973            name = field['name']
974
975            ## default trac value
976            #
977            if not field.get('custom'):
978                value = self.get_config('ticket', 'default_%s' %(name) )
979                if (name in ['resolution']) and (value in ['fixed']):
980                    value = None
981            else:
982                ##  Else get the default value for reporter
983                #
984                value = field.get('value')
985                options = field.get('options')
986
987                if value and options and (value not in options):
988                     value = options[int(value)]
989   
990            if self.parameters.debug:
991                s = 'trac[%s] = %s' %(name, value)
992                self.print_unicode(s)
993
994            ## email2trac.conf settings
995            #
996            prefix = self.parameters.ticket_prefix
997            try:
998                value = self.parameters['%s_%s' %(prefix, name)]
999                if self.parameters.debug:
1000                    s = 'email2trac[%s] = %s ' %(name, value)
1001                    self.print_unicode(s)
1002
1003            except KeyError, detail:
1004                pass
1005       
1006            if value:
1007                user_dict[name] = value
1008                if self.parameters.debug:
1009                    s = 'used %s = %s' %(name, value)
1010                    self.print_unicode(s)
1011
1012        self.update_ticket_fields(ticket, user_dict, new=1)
1013
1014        if 'status' not in user_dict.keys():
1015            ticket['status'] = 'new'
1016
1017
1018    def ticket_update_by_subject(self, subject):
1019        """
1020        This list of Re: prefixes is probably incomplete. Taken from
1021        wikipedia. Here is how the subject is matched
1022          - Re: <subject>
1023          - Re: (<Mail list label>:)+ <subject>
1024
1025        So we must have the last column
1026        """
1027        self.logger.debug('function ticket_update_by_subject')
1028
1029        matched_id = None
1030        if self.parameters.ticket_update and self.parameters.ticket_update_by_subject:
1031               
1032            SUBJECT_RE = re.compile(r'^(?:(?:RE|AW|VS|SV|FW|FWD):\s*)+(.*)', re.IGNORECASE)
1033            result = SUBJECT_RE.search(subject)
1034
1035            if result:
1036                ## This is a reply
1037                #
1038                orig_subject = result.group(1)
1039
1040                self.logger.debug('subject search string: %s' %(orig_subject))
1041
1042                cursor = self.db.cursor()
1043                summaries = [orig_subject, '%%: %s' % orig_subject]
1044
1045                ## Time resolution is in micoseconds
1046                #
1047                search_date = datetime.now(util.datefmt.utc) - timedelta(days=self.parameters.ticket_update_by_subject_lookback)
1048
1049                if self.VERSION < 0.12:
1050                    lookback = util.datefmt.to_timestamp(search_date)
1051                else:
1052                    lookback = util.datefmt.to_utimestamp(search_date)
1053
1054                for summary in summaries:
1055                    self.logger.debug('Looking for summary matching: "%s"' % summary)
1056
1057                    sql = """SELECT id FROM ticket
1058                            WHERE changetime >= %s AND summary LIKE %s
1059                            ORDER BY changetime DESC"""
1060                    cursor.execute(sql, [lookback, summary.strip()])
1061
1062                    for row in cursor:
1063                        (matched_id,) = row
1064
1065                        self.logger.debug('Found matching ticket id: %d' % matched_id)
1066
1067                        break
1068
1069                    if matched_id:
1070                        matched_id = '#%d' % matched_id
1071                        return (matched_id, orig_subject)
1072                   
1073                    subject = orig_subject
1074
1075        return (matched_id, subject)
1076
1077
1078    def new_ticket(self, msg, subject, spam, set_fields = None):
1079        """
1080        Create a new ticket
1081        """
1082        self.logger.debug('function new_ticket')
1083
1084        tkt = Ticket(self.env)
1085
1086        self.set_reply_fields(tkt, msg)
1087
1088        self.set_ticket_fields(tkt)
1089
1090        ## Check the permission of the reporter
1091        #
1092        if self.parameters.ticket_permission_system:
1093            if not self.check_permission(tkt, 'TICKET_CREATE'):
1094                self.logger.info('Reporter: %s has no permission to create tickets' %self.author)
1095                return False
1096
1097        ## Old style setting for component, will be removed
1098        #
1099        if spam:
1100            tkt['component'] = 'Spam'
1101
1102        elif self.parameters.has_key('component'):
1103            tkt['component'] = self.parameters['component']
1104
1105        if not msg['Subject']:
1106            tkt['summary'] = u'(No subject)'
1107        else:
1108            tkt['summary'] = subject
1109
1110
1111        if set_fields:
1112            rest, keywords = string.split(set_fields, '?')
1113
1114            if keywords:
1115                update_fields = self.str_to_dict(keywords)
1116                self.update_ticket_fields(tkt, update_fields)
1117
1118
1119        message_parts = self.get_message_parts(msg)
1120
1121        ## Must we update some ticket fields properties via body_text
1122        #
1123        if self.properties:
1124                self.update_ticket_fields(tkt, self.properties)
1125
1126        message_parts = self.unique_attachment_names(message_parts)
1127       
1128        ## produce e-mail like header
1129        #
1130        head = ''
1131        if self.parameters.email_header:
1132            head = self.email_header_txt(msg)
1133            message_parts.insert(0, head)
1134           
1135        body_text = self.get_body_text(message_parts)
1136
1137        tkt['description'] = body_text
1138
1139        ## When is the change committed
1140        #
1141        if self.VERSION < 0.11:
1142            when = int(time.time())
1143        else:
1144            when = datetime.now(util.datefmt.utc)
1145
1146        if self.parameters.dry_run:
1147            print 'DRY_RUN: tkt.insert()'
1148        else:
1149            self.id = tkt.insert()
1150   
1151        changed = False
1152        comment = ''
1153
1154        ## some routines in trac are dependend on ticket id
1155        #  like alternate notify template
1156        #
1157        if self.parameters.alternate_notify_template:
1158            tkt['id'] = self.id
1159            changed = True
1160
1161        ## Rewrite the description if we have mailto enabled
1162        #
1163        if self.parameters.mailto_link:
1164            changed = True
1165            comment = u'\nadded mailto line\n'
1166            mailto = self.html_mailto_link( m['Subject'])
1167
1168            tkt['description'] = u'%s\r\n%s%s\r\n' \
1169                %(head, mailto, body_text)
1170   
1171        ## Save the attachments to the ticket   
1172        #
1173        error_with_attachments =  self.attach_attachments(message_parts)
1174
1175        if error_with_attachments:
1176            changed = True
1177            comment = '%s\n%s\n' %(comment, error_with_attachments)
1178
1179        if changed:
1180            if self.parameters.dry_run:
1181                print 'DRY_RUN: tkt.save_changes(%s, comment) real reporter = %s' %( tkt['reporter'], self.author)
1182            else:
1183                tkt.save_changes(tkt['reporter'], comment)
1184                #print tkt.get_changelog(self.db, when)
1185
1186        if not spam:
1187            self.notify(tkt, True)
1188
1189
1190    def attach_attachments(self, message_parts, update=False):
1191        '''
1192        save any attachments as files in the ticket's directory
1193        '''
1194        self.logger.debug('function attach_attachments()')
1195
1196        if self.parameters.dry_run:
1197            print "DRY_RUN: no attachments attached to tickets"
1198            return ''
1199
1200        count = 0
1201
1202        ## Get Maxium attachment size
1203        #
1204        max_size = int(self.get_config('attachment', 'max_size'))
1205        status   = None
1206       
1207        for item in message_parts:
1208            ## Skip body parts
1209            #
1210            if not isinstance(item, tuple):
1211                continue
1212               
1213            (original, filename, part) = item
1214
1215            ## We have to determine the size so we use this temporary solution. we must escape it
1216            #  else we get UnicodeErrors.
1217            #
1218            path, fd =  util.create_unique_file(os.path.join(self.parameters.tmpdir, util.text.unicode_quote(filename)))
1219            text = part.get_payload(decode=1)
1220            if not text:
1221                text = '(None)'
1222            fd.write(text)
1223            fd.close()
1224
1225            ## get the file_size
1226            #
1227            stats = os.lstat(path)
1228            file_size = stats[ST_SIZE]
1229
1230            ## Check if the attachment size is allowed
1231            #
1232            if (max_size != -1) and (file_size > max_size):
1233                status = '%s\nFile %s is larger then allowed attachment size (%d > %d)\n\n' \
1234                    %(status, original, file_size, max_size)
1235
1236                os.unlink(path)
1237                continue
1238            else:
1239                count = count + 1
1240                   
1241            ## Insert the attachment
1242            #
1243            fd = open(path, 'rb')
1244            if self.system == 'discussion':
1245                att = attachment.Attachment(self.env, 'discussion', 'topic/%s'
1246                  % (self.id,))
1247            else:
1248                self.logger.debug('Attach %s to ticket %d' %(util.text.unicode_quote(filename), self.id))
1249                att = attachment.Attachment(self.env, 'ticket', self.id)
1250 
1251            ## This will break the ticket_update system, the body_text is vaporized
1252            #  ;-(
1253            #
1254            if not update:
1255                att.author = self.author
1256                att.description = self.email_to_unicode('Added by email2trac')
1257
1258            try:
1259                self.logger.debug('Insert atachment')
1260                att.insert(filename, fd, file_size)
1261            except OSError, detail:
1262                self.logger.info('%s\nFilename %s could not be saved, problem: %s' %(status, filename, detail))
1263                status = '%s\nFilename %s could not be saved, problem: %s' %(status, filename, detail)
1264
1265            ## Remove the created temporary filename
1266            #
1267            fd.close()
1268            os.unlink(path)
1269
1270        ## return error
1271        #
1272        return status
1273
1274########## Fullblog functions  #################################################
1275
1276    def blog(self, id):
1277        """
1278        The blog create/update function
1279        """
1280        ## import the modules
1281        #
1282        from tracfullblog.core import FullBlogCore
1283        from tracfullblog.model import BlogPost, BlogComment
1284        from trac.test import Mock, MockPerm
1285
1286        ## instantiate blog core
1287        #
1288        blog = FullBlogCore(self.env)
1289        req = Mock(authname='anonymous', perm=MockPerm(), args={})
1290
1291        if id:
1292
1293            ## update blog
1294            #
1295            comment = BlogComment(self.env, id)
1296            comment.author = self.author
1297
1298            message_parts = self.get_message_parts(m)
1299            comment.comment = self.get_body_text(message_parts)
1300
1301            blog.create_comment(req, comment)
1302
1303        else:
1304            ## create blog
1305            #
1306            import time
1307            post = BlogPost(self.env, 'blog_'+time.strftime("%Y%m%d%H%M%S", time.gmtime()))
1308
1309            #post = BlogPost(self.env, blog._get_default_postname(self.env))
1310           
1311            post.author = self.author
1312            post.title = self.email_to_unicode(m['Subject'])
1313
1314            message_parts = self.get_message_parts(m)
1315            post.body = self.get_body_text(message_parts)
1316           
1317            blog.create_post(req, post, self.author, u'Created by email2trac', False)
1318
1319
1320########## Discussion functions  ##############################################
1321
1322    def discussion_topic(self, content, subject):
1323
1324        ## Import modules.
1325        #
1326        from tracdiscussion.api import DiscussionApi
1327        from trac.util.datefmt import to_timestamp, utc
1328
1329        self.logger.debug('Creating a new topic in forum:', self.id)
1330
1331        ## Get dissussion API component.
1332        #
1333        api = self.env[DiscussionApi]
1334        context = self._create_context(content, subject)
1335
1336        ## Get forum for new topic.
1337        #
1338        forum = api.get_forum(context, self.id)
1339
1340        if not forum:
1341            self.logger.error("ERROR: Replied forum doesn't exist")
1342
1343        ## Prepare topic.
1344        #
1345        topic = {'forum' : forum['id'],
1346                 'subject' : context.subject,
1347                 'time': to_timestamp(datetime.now(utc)),
1348                 'author' : self.author,
1349                 'subscribers' : [self.email_addr],
1350                 'body' : self.get_body_text(context.content_parts)}
1351
1352        ## Add topic to DB and commit it.
1353        #
1354        self._add_topic(api, context, topic)
1355        self.db.commit()
1356
1357    def discussion_topic_reply(self, content, subject):
1358
1359        ## Import modules.
1360        #
1361        from tracdiscussion.api import DiscussionApi
1362        from trac.util.datefmt import to_timestamp, utc
1363
1364        self.logger.debug('Replying to discussion topic', self.id)
1365
1366        ## Get dissussion API component.
1367        #
1368        api = self.env[DiscussionApi]
1369        context = self._create_context(content, subject)
1370
1371        ## Get replied topic.
1372        #
1373        topic = api.get_topic(context, self.id)
1374
1375        if not topic:
1376            self.logger.error("ERROR: Replied topic doesn't exist")
1377
1378        ## Prepare message.
1379        #
1380        message = {'forum' : topic['forum'],
1381                   'topic' : topic['id'],
1382                   'replyto' : -1,
1383                   'time' : to_timestamp(datetime.now(utc)),
1384                   'author' : self.author,
1385                   'body' : self.get_body_text(context.content_parts)}
1386
1387        ## Add message to DB and commit it.
1388        #
1389        self._add_message(api, context, message)
1390        self.db.commit()
1391
1392    def discussion_message_reply(self, content, subject):
1393
1394        ## Import modules.
1395        #
1396        from tracdiscussion.api import DiscussionApi
1397        from trac.util.datefmt import to_timestamp, utc
1398
1399        self.logger.debug('Replying to discussion message', self.id)
1400
1401        ## Get dissussion API component.
1402        #
1403        api = self.env[DiscussionApi]
1404        context = self._create_context(content, subject)
1405
1406        ## Get replied message.
1407        #
1408        message = api.get_message(context, self.id)
1409
1410        if not message:
1411            self.logger.error("ERROR: Replied message doesn't exist")
1412
1413        ## Prepare message.
1414        #
1415        message = {'forum' : message['forum'],
1416                   'topic' : message['topic'],
1417                   'replyto' : message['id'],
1418                   'time' : to_timestamp(datetime.now(utc)),
1419                   'author' : self.author,
1420                   'body' : self.get_body_text(context.content_parts)}
1421
1422        ## Add message to DB and commit it.
1423        #
1424        self._add_message(api, context, message)
1425        self.db.commit()
1426
1427    def _create_context(self, content, subject):
1428
1429        ## Import modules.
1430        #
1431        from trac.mimeview import Context
1432        from trac.web.api import Request
1433        from trac.perm import PermissionCache
1434
1435        ## TODO: Read server base URL from config.
1436        #  Create request object to mockup context creation.
1437        #
1438        environ = {'SERVER_PORT' : 80,
1439                   'SERVER_NAME' : 'test',
1440                   'REQUEST_METHOD' : 'POST',
1441                   'wsgi.url_scheme' : 'http',
1442                   'wsgi.input' : sys.stdin}
1443        chrome =  {'links': {},
1444                   'scripts': [],
1445                   'ctxtnav': [],
1446                   'warnings': [],
1447                   'notices': []}
1448
1449        if self.env.base_url_for_redirect:
1450            environ['trac.base_url'] = self.env.base_url
1451
1452        req = Request(environ, None)
1453        req.chrome = chrome
1454        req.tz = 'missing'
1455        req.authname = self.author
1456        req.perm = PermissionCache(self.env, self.author)
1457        req.locale = None
1458
1459        ## Create and return context.
1460        #
1461        context = Context.from_request(req)
1462        context.realm = 'discussion-email2trac'
1463        context.cursor = self.db.cursor()
1464        context.content = content
1465        context.subject = subject
1466
1467        ## Read content parts from content.
1468        #
1469        context.content_parts = self.get_message_parts(content)
1470        context.content_parts = self.unique_attachment_names(
1471          context.content_parts)
1472
1473        return context
1474
1475    def _add_topic(self, api, context, topic):
1476        context.req.perm.assert_permission('DISCUSSION_APPEND')
1477
1478        ## Filter topic.
1479        #
1480        for discussion_filter in api.discussion_filters:
1481            accept, topic_or_error = discussion_filter.filter_topic(
1482              context, topic)
1483            if accept:
1484                topic = topic_or_error
1485            else:
1486                raise TracError(topic_or_error)
1487
1488        ## Add a new topic.
1489        #
1490        api.add_topic(context, topic)
1491
1492        ## Get inserted topic with new ID.
1493        #
1494        topic = api.get_topic_by_time(context, topic['time'])
1495
1496        ## Attach attachments.
1497        #
1498        self.id = topic['id']
1499        self.attach_attachments(context.content_parts, True)
1500
1501        ## Notify change listeners.
1502        #
1503        for listener in api.topic_change_listeners:
1504            listener.topic_created(context, topic)
1505
1506    def _add_message(self, api, context, message):
1507        context.req.perm.assert_permission('DISCUSSION_APPEND')
1508
1509        ## Filter message.
1510        #
1511        for discussion_filter in api.discussion_filters:
1512            accept, message_or_error = discussion_filter.filter_message(
1513              context, message)
1514            if accept:
1515                message = message_or_error
1516            else:
1517                raise TracError(message_or_error)
1518
1519        ## Add message.
1520        #
1521        api.add_message(context, message)
1522
1523        ## Get inserted message with new ID.
1524        #
1525        message = api.get_message_by_time(context, message['time'])
1526
1527        ## Attach attachments.
1528        #
1529        self.id = message['topic']
1530        self.attach_attachments(context.content_parts, True)
1531
1532        ## Notify change listeners.
1533        #
1534        for listener in api.message_change_listeners:
1535            listener.message_created(context, message)
1536
1537########## MAIN function  ######################################################
1538
1539    def parse(self, fp):
1540        """
1541        """
1542        self.logger.debug('Main function parse')
1543        global m
1544
1545        m = email.message_from_file(fp)
1546       
1547        if not m:
1548            self.logger.debug('This is not a valid email message format')
1549            return
1550           
1551        ## Work around lack of header folding in Python; see http://bugs.python.org/issue4696
1552        #
1553        try:
1554            m.replace_header('Subject', m['Subject'].replace('\r', '').replace('\n', ''))
1555        except AttributeError, detail:
1556            pass
1557
1558        if self.parameters.debug:     # save the entire e-mail message text
1559            self.save_email_for_debug(m, self.parameters.project_name, True)
1560
1561        self.db = self.env.get_db_cnx()
1562        self.get_sender_info(m)
1563
1564        if not self.email_header_acl('white_list', self.email_addr, True):
1565            self.logger.info('Message rejected : %s not in white list' %(self.email_addr))
1566            return False
1567
1568        if self.email_header_acl('black_list', self.email_addr, False):
1569            self.logger.info('Message rejected : %s in black list' %(self.email_addr))
1570            return False
1571
1572        if not self.email_header_acl('recipient_list', self.to_email_addr, True):
1573            self.logger.info('Message rejected : %s not in recipient list' %(self.to_email_addr))
1574            return False
1575
1576        ## If spam drop the message
1577        #
1578        if self.spam(m) == 'drop':
1579            return False
1580
1581        elif self.spam(m) == 'spam':
1582            spam_msg = True
1583        else:
1584            spam_msg = False
1585
1586        if not m['Subject']:
1587            subject  = 'No Subject'
1588        else:
1589            subject  = self.email_to_unicode(m['Subject'])
1590
1591        self.logger.info('subject: %s' %subject)
1592
1593        ## [hic] #1529: Re: LRZ
1594        #  [hic] #1529?owner=bas,priority=medium: Re: LRZ
1595        #
1596        ticket_regex = r'''
1597            (?P<new_fields>[#][?].*)
1598            |(?P<reply>(?P<id>[#][\d]+)(?P<fields>\?.*)?:)
1599            '''
1600        ## Check if  FullBlogPlugin is installed
1601        #
1602        blog_enabled = None
1603        blog_regex = ''
1604        if self.get_config('components', 'tracfullblog.*') in ['enabled']:
1605            self.logger.debug('Trac BLOG support enabled')
1606            blog_enabled = True
1607            blog_regex = '''|(?P<blog>blog:(?P<blog_id>\w*))'''
1608
1609
1610        ## Check if DiscussionPlugin is installed
1611        #
1612        discussion_enabled = None
1613        discussion_regex = ''
1614        if self.get_config('components', 'tracdiscussion.api.discussionapi') in ['enabled']:
1615            self.logger.debug('Trac Discussion support enabled')
1616            discussion_enabled = True
1617            discussion_regex = r'''
1618            |(?P<forum>Forum[ ][#](?P<forum_id>\d+)[ ]-[ ]?)
1619            |(?P<topic>Topic[ ][#](?P<topic_id>\d+)[ ]-[ ]?)
1620            |(?P<message>Message[ ][#](?P<message_id>\d+)[ ]-[ ]?)
1621            '''
1622
1623
1624        regex_str = ticket_regex + blog_regex + discussion_regex
1625        SYSTEM_RE = re.compile(regex_str, re.VERBOSE)
1626
1627        ## Find out if this is a ticket, a blog or a discussion
1628        #
1629        result =  SYSTEM_RE.search(subject)
1630
1631        if result:
1632            ## update ticket + fields
1633            #
1634            if result.group('reply'):
1635                self.system = 'ticket'
1636
1637                ## Skip the last ':' character
1638                #
1639                if not self.ticket_update(m, result.group('reply')[:-1], spam_msg):
1640                    self.new_ticket(m, subject, spam_msg)
1641
1642            ## New ticket + fields
1643            #
1644            elif result.group('new_fields'):
1645                self.system = 'ticket'
1646                self.new_ticket(m, subject[:result.start('new_fields')], spam_msg, result.group('new_fields'))
1647
1648            if blog_enabled:
1649                if result.group('blog'):
1650                    self.system = 'blog'
1651                    self.blog(result.group('blog_id'))
1652
1653            if discussion_enabled:
1654                ## New topic.
1655                #
1656                if result.group('forum'):
1657                    self.system = 'discussion'
1658                    self.id = int(result.group('forum_id'))
1659                    self.discussion_topic(m, subject[result.end('forum'):])
1660
1661                ## Reply to topic.
1662                #
1663                elif result.group('topic'):
1664                    self.system = 'discussion'
1665                    self.id = int(result.group('topic_id'))
1666                    self.discussion_topic_reply(m, subject[result.end('topic'):])
1667
1668                ## Reply to topic message.
1669                #
1670                elif result.group('message'):
1671                    self.system = 'discussion'
1672                    self.id = int(result.group('message_id'))
1673                    self.discussion_message_reply(m, subject[result.end('message'):])
1674
1675        else:
1676            self.system = 'ticket'
1677            (matched_id, subject) = self.ticket_update_by_subject(subject)
1678            if matched_id:
1679                if not self.ticket_update(m, matched_id, spam_msg):
1680                    self.new_ticket(m, subject, spam_msg)
1681            else:
1682                ## No update by subject, so just create a new ticket
1683                #
1684                self.new_ticket(m, subject, spam_msg)
1685
1686
1687########## BODY TEXT functions  ###########################################################
1688
1689    def strip_signature(self, text):
1690        """
1691        Strip signature from message, inspired by Mailman software
1692        """
1693        self.logger.debug('function strip_signature')
1694
1695        body = []
1696        for line in text.splitlines():
1697            if line == '-- ':
1698                break
1699            body.append(line)
1700
1701        return ('\n'.join(body))
1702
1703    def reflow(self, text, delsp = 0):
1704        """
1705        Reflow the message based on the format="flowed" specification (RFC 3676)
1706        """
1707        flowedlines = []
1708        quotelevel = 0
1709        prevflowed = 0
1710
1711        for line in text.splitlines():
1712            from re import match
1713           
1714            ## Figure out the quote level and the content of the current line
1715            #
1716            m = match('(>*)( ?)(.*)', line)
1717            linequotelevel = len(m.group(1))
1718            line = m.group(3)
1719
1720            ## Determine whether this line is flowed
1721            #
1722            if line and line != '-- ' and line[-1] == ' ':
1723                flowed = 1
1724            else:
1725                flowed = 0
1726
1727            if flowed and delsp and line and line[-1] == ' ':
1728                line = line[:-1]
1729
1730            ## If the previous line is flowed, append this line to it
1731            #
1732            if prevflowed and line != '-- ' and linequotelevel == quotelevel:
1733                flowedlines[-1] += line
1734
1735            ## Otherwise, start a new line
1736            #
1737            else:
1738                flowedlines.append('>' * linequotelevel + line)
1739
1740            prevflowed = flowed
1741           
1742
1743        return '\n'.join(flowedlines)
1744
1745    def strip_quotes(self, text):
1746        """
1747        Strip quotes from message by Nicolas Mendoza
1748        """
1749        self.logger.debug('function strip_quotes')
1750
1751        body = []
1752        for line in text.splitlines():
1753            try:
1754
1755                if line.startswith(self.parameters.email_quote):
1756                    continue
1757
1758            except UnicodeDecodeError:
1759
1760                tmp_line = self.email_to_unicode(line)
1761                if tmp_line.startswith(self.parameters.email_quote):
1762                    continue
1763               
1764            body.append(line)
1765
1766        return ('\n'.join(body))
1767
1768    def inline_properties(self, text):
1769        """
1770        Parse text if we use inline keywords to set ticket fields
1771        """
1772        self.logger.debug('function inline_properties')
1773
1774        properties = dict()
1775        body = list()
1776
1777        INLINE_EXP = re.compile('\s*[@]\s*(\w+)\s*:(.*)$')
1778
1779        for line in text.splitlines():
1780            match = INLINE_EXP.match(line)
1781            if match:
1782                keyword, value = match.groups()
1783
1784                if self.parameters.inline_properties_first_wins:
1785                    if keyword in self.properties.keys():
1786                        continue
1787
1788                self.properties[keyword] = value.strip()
1789                self.logger.debug('\tinline properties: %s : %s' %(keyword,value))
1790
1791            else:
1792                body.append(line)
1793               
1794        return '\n'.join(body)
1795
1796
1797    def wrap_text(self, text, replace_whitespace = False):
1798        """
1799        Will break a lines longer then given length into several small
1800        lines of size given length
1801        """
1802        import textwrap
1803
1804        LINESEPARATOR = '\n'
1805        reformat = ''
1806
1807        for s in text.split(LINESEPARATOR):
1808            tmp = textwrap.fill(s, self.parameters.use_textwrap)
1809            if tmp:
1810                reformat = '%s\n%s' %(reformat,tmp)
1811            else:
1812                reformat = '%s\n' %reformat
1813
1814        return reformat
1815
1816        # Python2.4 and higher
1817        #
1818        #return LINESEPARATOR.join(textwrap.fill(s,width) for s in str.split(LINESEPARATOR))
1819        #
1820
1821########## EMAIL attachements functions ###########################################################
1822
1823    def inline_part(self, part):
1824        """
1825        """
1826        self.logger.debug('function inline_part()')
1827
1828        return part.get_param('inline', None, 'Content-Disposition') == '' or not part.has_key('Content-Disposition')
1829
1830    def get_message_parts(self, msg):
1831        """
1832        parses the email message and returns a list of body parts and attachments
1833        body parts are returned as strings, attachments are returned as tuples of (filename, Message object)
1834        """
1835        self.logger.debug('function get_message_parts()')
1836
1837        message_parts = list()
1838   
1839        ALTERNATIVE_MULTIPART = False
1840
1841        for part in msg.walk():
1842            content_maintype = part.get_content_maintype()
1843            content_type =  part.get_content_type()
1844
1845            self.logger.debug('\t Message part: Main-Type: %s' % content_maintype)
1846            self.logger.debug('\t Message part: Content-Type: %s' % content_type)
1847
1848            ## Check content type
1849            #
1850            if content_type in self.STRIP_CONTENT_TYPES:
1851                self.logger.debug("\t A %s attachment named '%s' was skipped" %(content_type, part.get_filename()))
1852                continue
1853
1854            ## Catch some mulitpart execptions
1855            #
1856            if content_type == 'multipart/alternative':
1857                ALTERNATIVE_MULTIPART = True
1858                continue
1859
1860            ## Skip multipart containers
1861            #
1862            if content_maintype == 'multipart':
1863                self.logger.debug("\t Skipping multipart container")
1864                continue
1865           
1866            ## 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"
1867            #
1868            inline = self.inline_part(part)
1869
1870            ## Drop HTML message
1871            #
1872            if ALTERNATIVE_MULTIPART and self.parameters.drop_alternative_html_version:
1873                if content_type == 'text/html':
1874                    self.logger.debug('\t Skipping alternative HTML message')
1875                    ALTERNATIVE_MULTIPART = False
1876                    continue
1877
1878
1879            ## Save all non plain text message as attachment
1880            #
1881            if not content_type in ['text/plain']:
1882
1883                if self.parameters.debug:
1884                    s = '\t Filename: %s' % part.get_filename()
1885                    self.print_unicode(s)
1886
1887                ## First try to use email header function to convert filename.
1888                #  If this fails the use the plain filename
1889                #
1890                try:
1891                    filename = self.email_to_unicode(part.get_filename())
1892                except UnicodeEncodeError, detail:
1893                    filename = part.get_filename()
1894
1895                message_parts.append((filename, part))
1896
1897                ## We van only convert html messages
1898                #
1899                if not content_type == 'text/html':
1900                    self.logger.debug('\t Appending content_type = %s' %(content_type))
1901                    continue
1902
1903            if not inline:
1904                    self.logger.debug('\t Skipping %s, not an inline messsage part' %(content_type))
1905                    continue
1906               
1907            ## Try to decode message part. We have a html or plain text messafe
1908            #
1909            body_text = part.get_payload(decode=1)
1910            if not body_text:           
1911                body_text = part.get_payload(decode=0)
1912
1913            ## Try to convert html message
1914            #
1915            if content_type == 'text/html':
1916
1917                body_text = self.html_2_txt(body_text)
1918                if not body_text:
1919                    continue
1920
1921            format = email.Utils.collapse_rfc2231_value(part.get_param('Format', 'fixed')).lower()
1922            delsp = email.Utils.collapse_rfc2231_value(part.get_param('DelSp', 'no')).lower()
1923
1924            if self.parameters.reflow and not self.parameters.verbatim_format and format == 'flowed':
1925                body_text = self.reflow(body_text, delsp == 'yes')
1926   
1927            if self.parameters.strip_signature:
1928                body_text = self.strip_signature(body_text)
1929
1930            if self.parameters.strip_quotes:
1931                body_text = self.strip_quotes(body_text)
1932
1933            if self.parameters.inline_properties:
1934                body_text = self.inline_properties(body_text)
1935
1936            if self.parameters.use_textwrap:
1937                body_text = self.wrap_text(body_text)
1938
1939            ## Get contents charset (iso-8859-15 if not defined in mail headers)
1940            #
1941            charset = part.get_content_charset()
1942            if not charset:
1943                charset = 'iso-8859-15'
1944
1945            try:
1946                ubody_text = unicode(body_text, charset)
1947
1948            except UnicodeError, detail:
1949                ubody_text = unicode(body_text, 'iso-8859-15')
1950
1951            except LookupError, detail:
1952                ubody_text = 'ERROR: Could not find charset: %s, please install' %(charset)
1953
1954            if self.parameters.verbatim_format:
1955                message_parts.append('{{{\r\n%s\r\n}}}' %ubody_text)
1956            else:
1957                message_parts.append('%s' %ubody_text)
1958
1959        return message_parts
1960       
1961    def unique_attachment_names(self, message_parts):
1962        """
1963        Make sure we have unique names attachments:
1964          - check if it contains illegal characters
1965          - Rename "None" filenames to "untitled-part"
1966        """
1967        self.logger.debug('function unique_attachment_names()')
1968        renamed_parts = []
1969        attachment_names = set()
1970
1971        for item in message_parts:
1972           
1973            ## If not an attachment, leave it alone
1974            #
1975            if not isinstance(item, tuple):
1976                renamed_parts.append(item)
1977                continue
1978               
1979            (filename, part) = item
1980
1981            ## If filename = None, use a default one
1982            #
1983            if filename in [ 'None']:
1984                filename = 'untitled-part'
1985                self.logger.info('Rename filename "None" to: %s' %filename)
1986
1987                ## Guess the extension from the content type, use non strict mode
1988                #  some additional non-standard but commonly used MIME types
1989                #  are also recognized
1990                #
1991                ext = mimetypes.guess_extension(part.get_content_type(), False)
1992                if not ext:
1993                    ext = '.bin'
1994
1995                filename = '%s%s' % (filename, ext)
1996
1997            ## Discard relative paths for windows/unix in attachment names
1998            #
1999            #filename = filename.replace('\\', '/').replace(':', '/')
2000            filename = filename.replace('\\', '_')
2001            filename = filename.replace('/', '_')
2002
2003            ## remove linefeed char
2004            #
2005            for forbidden_char in ['\r', '\n']:
2006                filename = filename.replace(forbidden_char,'')
2007
2008            ## We try to normalize the filename to utf-8 NFC if we can.
2009            #  Files uploaded from OS X might be in NFD.
2010            #  Check python version and then try it
2011            #
2012            #if sys.version_info[0] > 2 or (sys.version_info[0] == 2 and sys.version_info[1] >= 3):
2013            #   try:
2014            #       filename = unicodedata.normalize('NFC', unicode(filename, 'utf-8')).encode('utf-8') 
2015            #   except TypeError:
2016            #       pass
2017
2018            ## Make the filename unique for this ticket
2019            #
2020            num = 0
2021            unique_filename = filename
2022            dummy_filename, ext = os.path.splitext(filename)
2023
2024            while (unique_filename in attachment_names) or self.attachment_exists(unique_filename):
2025                num += 1
2026                unique_filename = "%s-%s%s" % (dummy_filename, num, ext)
2027               
2028            if self.parameters.debug:
2029                s = 'Attachment with filename %s will be saved as %s' % (filename, unique_filename)
2030                self.print_unicode(s)
2031
2032            attachment_names.add(unique_filename)
2033
2034            renamed_parts.append((filename, unique_filename, part))
2035   
2036        return renamed_parts
2037           
2038           
2039    def attachment_exists(self, filename):
2040
2041        if self.parameters.debug:
2042            s = 'attachment already exists: Id : %s, Filename : %s' %(self.id, filename)
2043            self.print_unicode(s)
2044
2045        ## We have no valid ticket id
2046        #
2047        if not self.id:
2048            return False
2049
2050        try:
2051            if self.system == 'discussion':
2052                att = attachment.Attachment(self.env, 'discussion', 'ticket/%s'
2053                  % (self.id,), filename)
2054            else:
2055                att = attachment.Attachment(self.env, 'ticket', self.id,
2056                  filename)
2057            return True
2058        except attachment.ResourceNotFound:
2059            return False
2060
2061########## TRAC Ticket Text ###########################################################
2062           
2063    def get_body_text(self, message_parts):
2064        """
2065        """
2066        self.logger.debug('function get_body_text()')
2067
2068        body_text = []
2069       
2070        for part in message_parts:
2071       
2072            ## Plain text part, append it
2073            #
2074            if not isinstance(part, tuple):
2075                body_text.extend(part.strip().splitlines())
2076                body_text.append("")
2077                continue
2078
2079            (original, filename, part) = part
2080            inline = self.inline_part(part)
2081
2082            ## Skip generation of attachment link if html is converted to text
2083            #
2084            if part.get_content_type() == 'text/html' and self.parameters.html2text_cmd and inline:
2085                s = 'Skipping attachment link for html part: %s' %(filename)
2086                self.print_unicode(s)
2087                continue
2088           
2089            if part.get_content_maintype() == 'image' and inline:
2090                if self.system != 'discussion':
2091                    s = 'wiki image link for: %s' %(filename)
2092                    self.print_unicode(s)
2093                    body_text.append('[[Image(%s)]]' % filename)
2094                body_text.append("")
2095            else:
2096                if self.system != 'discussion':
2097                    s = 'wiki attachment link for: %s' %(filename)
2098                    self.print_unicode(s)
2099                    body_text.append('[attachment:"%s"]' % filename)
2100                body_text.append("")
2101
2102        ## Convert list body_texts to string
2103        #
2104        body_text = '\r\n'.join(body_text)
2105        return body_text
2106
2107    def html_mailto_link(self, subject):
2108        """
2109        This function returns a HTML mailto tag with the ticket id and author email address
2110        """
2111        self.logger.debug("function html_mailto_link")
2112        if not self.author:
2113            author = self.email_addr
2114        else:   
2115            author = self.author
2116
2117        if not self.parameters.mailto_cc:
2118            self.parameters.mailto_cc = ''
2119
2120        ## use urllib to escape the chars
2121        #
2122        s = '%s?Subject=%s&cc=%s' %(
2123               urllib.quote(self.email_addr),
2124               urllib.quote('Re: #%s: %s' %(self.id, subject)),
2125               urllib.quote(self.parameters.mailto_cc)
2126               )
2127
2128        if self.VERSION in [ 0.10 ]:
2129            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)
2130        else:
2131            s = '[mailto:"%s" Reply to: %s]' %(s, author)
2132
2133        self.logger.debug("\tmailto link %s" %s)
2134        return s
2135
2136########## TRAC notify section ###########################################################
2137
2138    def notify(self, tkt, new=True, modtime=0):
2139        """
2140        A wrapper for the TRAC notify function. So we can use templates
2141        """
2142        self.logger.debug('function notify()')
2143
2144        if self.parameters.notify_reporter:
2145            self.logger.debug('\t Notify reporter set')
2146            global sender_email
2147            sender_email = self.email_addr
2148 
2149            self.logger.debug('\t Using Email2TracNotification function AlwaysNotifyReporter')
2150            import trac.notification as Email2TracNotification
2151            Email2TracNotification.Notify.notify = AlwaysNotifyReporter
2152
2153        if self.parameters.dry_run  :
2154                print 'DRY_RUN: self.notify(tkt, True) reporter = %s' %tkt['reporter']
2155                return
2156        try:
2157
2158            #from trac.ticket.web_ui import TicketModule
2159            #from trac.ticket.notification import TicketNotificationSystem
2160            #ticket_sys = TicketNotificationSystem(self.env)
2161            #a = TicketModule(self.env)
2162            #print a.__dict__
2163            #tn_sys = TicketNotificationSystem(self.env)
2164            #print tn_sys
2165            #print tn_sys.__dict__
2166            #sys.exit(0)
2167
2168            ## create false {abs_}href properties, to trick Notify()
2169            #
2170            if not (self.VERSION in [0.11, 0.12]):
2171                self.env.abs_href = Href(self.get_config('project', 'url'))
2172                self.env.href = Href(self.get_config('project', 'url'))
2173
2174            tn = TicketNotifyEmail(self.env)
2175
2176            if self.parameters.alternate_notify_template:
2177
2178                if self.VERSION >= 0.11:
2179
2180                    from trac.web.chrome import Chrome
2181
2182                    if  self.parameters.alternate_notify_template_update and not new:
2183                        tn.template_name = self.parameters.alternate_notify_template_update
2184                    else:
2185                        tn.template_name = self.parameters.alternate_notify_template
2186
2187                    tn.template = Chrome(tn.env).load_template(tn.template_name, method='text')
2188                       
2189                else:
2190
2191                    tn.template_name = self.parameters.alternate_notify_template
2192
2193            tn.notify(tkt, new, modtime)
2194
2195        except Exception, e:
2196            self.logger.error('Failure sending notification on creation of ticket #%s: %s' %(self.id, e))
2197
2198########## END Class Definition  ########################################################
2199
2200########## Global Notificaition Function ################################################
2201def AlwaysNotifyReporter(self, resid):
2202    """
2203    Copy of def notify() to manipulate recipents to always include reporter for the
2204    notification.
2205    """
2206    (torcpts, ccrcpts) = self.get_recipients(resid)
2207
2208    if not tktparser.email_header_acl('notify_reporter_black_list', sender_email, False):
2209        ## additionally append sender (regardeless of settings in trac.ini)
2210        #
2211        if not sender_email in torcpts:
2212            torcpts.append(sender_email)
2213
2214    self.begin_send()
2215    self.send(torcpts, ccrcpts)
2216    self.finish_send()
2217
2218########## Parse Config File  ###########################################################
2219
2220def ReadConfig(file, name):
2221    """
2222    Parse the config file
2223    """
2224    if not os.path.isfile(file):
2225        print 'File %s does not exist' %file
2226        sys.exit(1)
2227
2228    config = trac_config.Configuration(file)
2229   
2230    parentdir = config.get('DEFAULT', 'parentdir')
2231    sections = config.sections()
2232
2233    ## use some trac internals to get the defaults
2234    #
2235    tmp = config.parser.defaults()
2236    project =  SaraDict()
2237
2238    for option, value in tmp.items():
2239        try:
2240            project[option] = int(value)
2241        except ValueError:
2242            project[option] = value
2243
2244    if name:
2245        if name in sections:
2246            project =  SaraDict()
2247            for option, value in  config.options(name):
2248                try:
2249                    project[option] = int(value)
2250                except ValueError:
2251                    project[option] = value
2252
2253        elif not parentdir:
2254            print "Not a valid project name: %s, valid names are: %s" %(name, sections)
2255            print "or set parentdir in the [DEFAULT] section"
2256            sys.exit(1)
2257
2258    ## If parentdir then set project dir to parentdir + name
2259    #
2260    if not project.has_key('project'):
2261        if not parentdir:
2262            print "You must set project or parentdir in your configuration file"
2263            sys.exit(1)
2264        elif not name:
2265            print "You must configure a  project section in your configuration file"
2266        else:
2267            project['project'] = os.path.join(parentdir, name)
2268
2269    ##
2270    # Save the project name
2271    #
2272    project['project_name'] = os.path.basename(project['project'])
2273
2274    return project
2275
2276########## Setup Logging ###############################################################
2277
2278def setup_log(parameters, project_name, interactive=None):
2279    """
2280    Setup logging
2281
2282    Note for log format the usage of `$(...)s` instead of `%(...)s` as the latter form
2283    would be interpreted by the ConfigParser itself.
2284    """
2285    logger = logging.getLogger('email2trac %s' %project_name)
2286
2287    if interactive:
2288        parameters.log_type = 'stderr'
2289
2290    if not parameters.log_type:
2291        if sys.platform in ['win32', 'cygwin']:
2292            parameters.log_type = 'eventlog'
2293        else:
2294            parameters.log_type = 'syslog'
2295
2296    if parameters.log_type == 'file':
2297
2298        if not parameters.log_file:
2299            parameters.log_file = 'email2trac.log'
2300
2301        if not os.path.isabs(parameters.log_file):
2302            parameters.log_file = os.path.join(tempfile.gettempdir(), parameters.log_file)
2303
2304        log_handler = logging.FileHandler(parameters.log_file)
2305
2306    elif parameters.log_type in ('winlog', 'eventlog', 'nteventlog'):
2307        ## Requires win32 extensions
2308        #
2309        log_handler = logging.handlers.NTEventLogHandler(logid, logtype='Application')
2310
2311    elif parameters.log_type in ('syslog', 'unix'):
2312        log_handler = logging.handlers.SysLogHandler('/dev/log')
2313
2314    elif parameters.log_type in ('stderr'):
2315        log_handler = logging.StreamHandler(sys.stderr)
2316
2317    else:
2318        log_handler = logging.handlers.BufferingHandler(0)
2319
2320    if parameters.log_format:
2321        parameters.log_format = parameters.log_format.replace('$(', '%(')
2322    else:
2323        parameters.log_format = '%(name)s: %(message)s'
2324        if parameters.log_type in ('file', 'stderr'):
2325            parameters.log_format = '%(asctime)s ' + parameters.log_format
2326
2327    log_formatter = logging.Formatter(parameters.log_format)
2328    log_handler.setFormatter(log_formatter)
2329    logger.addHandler(log_handler)
2330
2331    if (parameters.log_level in ['DEBUG', 'ALL']) or (parameters.debug > 0):
2332        logger.setLevel(logging.DEBUG)
2333        parameters.debug = 1
2334
2335    elif parameters.log_level in ['INFO'] or parameters.verbose:
2336        logger.setLevel(logging.INFO)
2337
2338    elif parameters.log_level in ['WARNING']:
2339        logger.setLevel(logging.WARNING)
2340
2341    elif parameters.log_level in ['ERROR']:
2342        logger.setLevel(logging.ERROR)
2343
2344    elif parameters.log_level in ['CRITICAL']:
2345        logger.setLevel(logging.CRITICAL)
2346
2347    else:
2348        logger.setLevel(logging.INFO)
2349
2350    return logger
2351
2352
2353if __name__ == '__main__':
2354    ## Default config file
2355    #
2356    configfile = '@email2trac_conf@'
2357    project = ''
2358    component = ''
2359    ticket_prefix = 'default'
2360    dry_run = None
2361    verbose = None
2362    debug_interactive = None
2363
2364    SHORT_OPT = 'cdhf:np:t:v'
2365    LONG_OPT  =  ['component=', 'debug', 'dry-run', 'help', 'file=', 'project=', 'ticket_prefix=', 'verbose']
2366
2367    try:
2368        opts, args = getopt.getopt(sys.argv[1:], SHORT_OPT, LONG_OPT)
2369    except getopt.error,detail:
2370        print __doc__
2371        print detail
2372        sys.exit(1)
2373   
2374    project_name = None
2375    for opt,value in opts:
2376        if opt in [ '-h', '--help']:
2377            print __doc__
2378            sys.exit(0)
2379        elif opt in ['-c', '--component']:
2380            component = value
2381        elif opt in ['-d', '--debug']:
2382            debug_interactive = 1
2383        elif opt in ['-f', '--file']:
2384            configfile = value
2385        elif opt in ['-n', '--dry-run']:
2386            dry_run = True
2387        elif opt in ['-p', '--project']:
2388            project_name = value
2389        elif opt in ['-t', '--ticket_prefix']:
2390            ticket_prefix = value
2391        elif opt in ['-v', '--verbose']:
2392            verbose = True
2393   
2394    settings = ReadConfig(configfile, project_name)
2395
2396    ## The default prefix for ticket values in email2trac.conf
2397    #
2398    settings.ticket_prefix = ticket_prefix
2399    settings.dry_run = dry_run
2400    settings.verbose = verbose
2401
2402    if not settings.debug and debug_interactive:
2403        settings.debug = debug_interactive
2404
2405    if not settings.project:
2406        print __doc__
2407        print 'No Trac project is defined in the email2trac config file.'
2408        sys.exit(1)
2409
2410    logger = setup_log(settings, os.path.basename(settings.project), debug_interactive)
2411   
2412    if component:
2413        settings['component'] = component
2414
2415    ## Determine major trac version used to be in email2trac.conf
2416    # Quick hack for 0.12
2417    #
2418    version = '0.%s' %(trac_version.split('.')[1])
2419    if version.startswith('0.12'):
2420        version = '0.12'
2421
2422    logger.debug("Found trac version: %s" %(version))
2423   
2424    try:
2425        if version == '0.10':
2426            from trac import attachment
2427            from trac.env import Environment
2428            from trac.ticket import Ticket
2429            from trac.web.href import Href
2430            from trac import util
2431            from trac.ticket.web_ui import TicketModule
2432
2433            #
2434            # return  util.text.to_unicode(str)
2435            #
2436            # see http://projects.edgewall.com/trac/changeset/2799
2437            from trac.ticket.notification import TicketNotifyEmail
2438            from trac import config as trac_config
2439            from trac.core import TracError
2440
2441        elif version == '0.11':
2442            from trac import attachment
2443            from trac.env import Environment
2444            from trac.ticket import Ticket
2445            from trac.web.href import Href
2446            from trac import config as trac_config
2447            from trac import util
2448            from trac.core import TracError
2449            from trac.perm import PermissionSystem
2450            from trac.ticket.web_ui import TicketModule
2451
2452            #
2453            # return  util.text.to_unicode(str)
2454            #
2455            # see http://projects.edgewall.com/trac/changeset/2799
2456            from trac.ticket.notification import TicketNotifyEmail
2457
2458        elif version == '0.12':
2459            from trac import attachment
2460            from trac.env import Environment
2461            from trac.ticket import Ticket
2462            from trac.web.href import Href
2463            from trac import config as trac_config
2464            from trac import util
2465            from trac.core import TracError
2466            from trac.perm import PermissionSystem
2467            from trac.ticket.web_ui import TicketModule
2468
2469            #
2470            # return  util.text.to_unicode(str)
2471            #
2472            # see http://projects.edgewall.com/trac/changeset/2799
2473            from trac.ticket.notification import TicketNotifyEmail
2474
2475
2476        else:
2477            logger.error('TRAC version %s is not supported' %version)
2478            sys.exit(0)
2479
2480        ## Must be set before environment is created
2481        #
2482        if settings.has_key('python_egg_cache'):
2483            python_egg_cache = str(settings['python_egg_cache'])
2484            os.environ['PYTHON_EGG_CACHE'] = python_egg_cache
2485
2486        if settings.debug > 0:
2487            logger.debug('Loading environment %s', settings.project)
2488
2489        try:
2490            env = Environment(settings['project'], create=0)
2491        except IOError, detail:
2492            logger.error("Trac project does not exists: %s" %settings['project'])
2493            sys.exit(0)
2494
2495        tktparser = TicketEmailParser(env, settings, logger, float(version))
2496        tktparser.parse(sys.stdin)
2497
2498    ## Catch all errors and use the logging module
2499    #
2500    except Exception, error:
2501
2502        etype, evalue, etb = sys.exc_info()
2503        for e in traceback.format_exception(etype, evalue, etb):
2504            logger.critical(e)
2505
2506        if m:
2507            tktparser.save_email_for_debug(m, settings.project_name, True)
2508
2509        sys.exit(1)
2510# EOB
Note: See TracBrowser for help on using the repository browser.