source: trunk/email2trac.py.in @ 557

Last change on this file since 557 was 557, checked in by bas, 9 years ago

delete obsolete workflow code, see #226

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