source: trunk/email2trac.py.in @ 311

Last change on this file since 311 was 311, checked in by bas, 14 years ago

email2trac.py.in:

  • removed debug print statement for inline_properties
  • Property svn:executable set to *
  • Property svn:keywords set to Id
File size: 42.0 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    trac_version : 0.10              # OPTIONAL, default is 0.11
45
46    [jouvin]                         # OPTIONAL project declaration, if set both fields necessary
47    project      : /data/trac/jouvin # use -p|--project jouvin. 
48       
49 * default config file is : /etc/email2trac.conf
50
51 * Commandline opions:
52                -h,--help
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 311 2010-02-02 15:56:41Z bas $
60"""
61import os
62import sys
63import string
64import getopt
65import stat
66import time
67import email
68import email.Iterators
69import email.Header
70import re
71import urllib
72import unicodedata
73from stat import *
74import mimetypes
75import traceback
76
77
78# Will fail where unavailable, e.g. Windows
79#
80try:
81    import syslog
82    SYSLOG_AVAILABLE = True
83except ImportError:
84    SYSLOG_AVAILABLE = False
85
86from datetime import tzinfo, timedelta, datetime
87from trac import config as trac_config
88
89# Some global variables
90#
91trac_default_version = '0.11'
92m = None
93
94# A UTC class needed for trac version 0.11, added by
95# tbaschak at ktc dot mb dot ca
96#
97class UTC(tzinfo):
98        """UTC"""
99        ZERO = timedelta(0)
100        HOUR = timedelta(hours=1)
101       
102        def utcoffset(self, dt):
103                return self.ZERO
104               
105        def tzname(self, dt):
106                return "UTC"
107               
108        def dst(self, dt):
109                return self.ZERO
110
111
112class TicketEmailParser(object):
113        env = None
114        comment = '> '
115   
116        def __init__(self, env, parameters, version):
117                self.env = env
118
119                # Database connection
120                #
121                self.db = None
122
123                # Save parameters
124                #
125                self.parameters = parameters
126
127                # Some useful mail constants
128                #
129                self.email_name = None
130                self.email_addr = None
131                self.email_from = None
132                self.author     = None
133                self.id         = None
134               
135                self.STRIP_CONTENT_TYPES = list()
136
137                self.VERSION = version
138                self.DRY_RUN = parameters['dry_run']
139
140                self.get_config = self.env.config.get
141
142                if parameters.has_key('umask'):
143                        os.umask(int(parameters['umask'], 8))
144
145                if parameters.has_key('debug'):
146                        self.DEBUG = int(parameters['debug'])
147                else:
148                        self.DEBUG = 0
149
150                if parameters.has_key('mailto_link'):
151                        self.MAILTO = int(parameters['mailto_link'])
152                        if parameters.has_key('mailto_cc'):
153                                self.MAILTO_CC = parameters['mailto_cc']
154                        else:
155                                self.MAILTO_CC = ''
156                else:
157                        self.MAILTO = 0
158
159                if parameters.has_key('spam_level'):
160                        self.SPAM_LEVEL = int(parameters['spam_level'])
161                else:
162                        self.SPAM_LEVEL = 0
163
164                if parameters.has_key('spam_header'):
165                        self.SPAM_HEADER = parameters['spam_header']
166                else:
167                        self.SPAM_HEADER = 'X-Spam-Score'
168
169                if parameters.has_key('email_quote'):
170                        self.EMAIL_QUOTE = str(parameters['email_quote'])
171                else:   
172                        self.EMAIL_QUOTE = '> '
173
174                if parameters.has_key('email_header'):
175                        self.EMAIL_HEADER = int(parameters['email_header'])
176                else:
177                        self.EMAIL_HEADER = 0
178
179                if parameters.has_key('alternate_notify_template'):
180                        self.notify_template = str(parameters['alternate_notify_template'])
181                else:
182                        self.notify_template = None
183
184                if parameters.has_key('alternate_notify_template_update'):
185                        self.notify_template_update = str(parameters['alternate_notify_template_update'])
186                else:
187                        self.notify_template_update = None
188
189                if parameters.has_key('reply_all'):
190                        self.REPLY_ALL = int(parameters['reply_all'])
191                else:
192                        self.REPLY_ALL = 0
193
194                if parameters.has_key('ticket_update'):
195                        self.TICKET_UPDATE = int(parameters['ticket_update'])
196                else:
197                        self.TICKET_UPDATE = 0
198
199                if parameters.has_key('drop_spam'):
200                        self.DROP_SPAM = int(parameters['drop_spam'])
201                else:
202                        self.DROP_SPAM = 0
203
204                if parameters.has_key('verbatim_format'):
205                        self.VERBATIM_FORMAT = int(parameters['verbatim_format'])
206                else:
207                        self.VERBATIM_FORMAT = 1
208
209                if parameters.has_key('reflow'):
210                        self.REFLOW = int(parameters['reflow'])
211                else:
212                        self.REFLOW = 1
213
214                if parameters.has_key('drop_alternative_html_version'):
215                        self.DROP_ALTERNATIVE_HTML_VERSION = int(parameters['drop_alternative_html_version'])
216                else:
217                        self.DROP_ALTERNATIVE_HTML_VERSION = 0
218
219                if parameters.has_key('strip_signature'):
220                        self.STRIP_SIGNATURE = int(parameters['strip_signature'])
221                else:
222                        self.STRIP_SIGNATURE = 0
223
224                if parameters.has_key('strip_quotes'):
225                        self.STRIP_QUOTES = int(parameters['strip_quotes'])
226                else:
227                        self.STRIP_QUOTES = 0
228
229                self.properties = dict()
230                if parameters.has_key('inline_properties'):
231                        self.INLINE_PROPERTIES = int(parameters['inline_properties'])
232                else:
233                        self.INLINE_PROPERTIES = 0
234
235                if parameters.has_key('use_textwrap'):
236                        self.USE_TEXTWRAP = int(parameters['use_textwrap'])
237                else:
238                        self.USE_TEXTWRAP = 0
239
240                if parameters.has_key('binhex'):
241                        self.STRIP_CONTENT_TYPES.append('application/mac-binhex40')
242
243                if parameters.has_key('applesingle'):
244                        self.STRIP_CONTENT_TYPES.append('application/applefile')
245
246                if parameters.has_key('appledouble'):
247                        self.STRIP_CONTENT_TYPES.append('application/applefile')
248
249                if parameters.has_key('strip_content_types'):
250                        items = parameters['strip_content_types'].split(',')
251                        for item in items:
252                                self.STRIP_CONTENT_TYPES.append(item.strip())
253
254                self.WORKFLOW = None
255                if parameters.has_key('workflow'):
256                        self.WORKFLOW = parameters['workflow']
257
258                # Use OS independend functions
259                #
260                self.TMPDIR = os.path.normcase('/tmp')
261                if parameters.has_key('tmpdir'):
262                        self.TMPDIR = os.path.normcase(str(parameters['tmpdir']))
263
264                if parameters.has_key('ignore_trac_user_settings'):
265                        self.IGNORE_TRAC_USER_SETTINGS = int(parameters['ignore_trac_user_settings'])
266                else:
267                        self.IGNORE_TRAC_USER_SETTINGS = 0
268
269                if parameters.has_key('subject_field_separator'):
270                        self.SUBJECT_FIELD_SEPARATOR = parameters['subject_field_separator'].strip()
271                else:
272                        self.SUBJECT_FIELD_SEPARATOR = '&'
273
274                self.trac_smtp_from = self.get_config('notification', 'smtp_from')
275
276        def spam(self, message):
277                """
278                # X-Spam-Score: *** (3.255) BAYES_50,DNS_FROM_AHBL_RHSBL,HTML_
279                # Note if Spam_level then '*' are included
280                """
281                spam = False
282                if message.has_key(self.SPAM_HEADER):
283                        spam_l = string.split(message[self.SPAM_HEADER])
284
285                        try:
286                                number = spam_l[0].count('*')
287                        except IndexError, detail:
288                                number = 0
289                               
290                        if number >= self.SPAM_LEVEL:
291                                spam = True
292                               
293                # treat virus mails as spam
294                #
295                elif message.has_key('X-Virus-found'):                 
296                        spam = True
297
298                # How to handle SPAM messages
299                #
300                if self.DROP_SPAM and spam:
301                        if self.DEBUG > 2 :
302                                print 'This message is a SPAM. Automatic ticket insertion refused (SPAM level > %d' % self.SPAM_LEVEL
303
304                        return 'drop'   
305
306                elif spam:
307
308                        return 'Spam'   
309
310                else:
311
312                        return False
313
314        def email_header_acl(self, keyword, header_field, default):
315                """
316                This function wil check if the email address is allowed or denied
317                to send mail to the ticket list
318            """
319                try:
320                        mail_addresses = self.parameters[keyword]
321
322                        # Check if we have an empty string
323                        #
324                        if not mail_addresses:
325                                return default
326
327                except KeyError, detail:
328                        if self.DEBUG > 2 :
329                                print 'TD: %s not defined, all messages are allowed.' %(keyword)
330
331                        return default
332
333                mail_addresses = string.split(mail_addresses, ',')
334
335                for entry in mail_addresses:
336                        entry = entry.strip()
337                        TO_RE = re.compile(entry, re.VERBOSE|re.IGNORECASE)
338                        result =  TO_RE.search(header_field)
339                        if result:
340                                return True
341
342                return False
343
344        def email_to_unicode(self, message_str):
345                """
346                Email has 7 bit ASCII code, convert it to unicode with the charset
347        that is encoded in 7-bit ASCII code and encode it as utf-8 so Trac
348                understands it.
349                """
350                results =  email.Header.decode_header(message_str)
351                s = None
352                for text,format in results:
353                        if format:
354                                try:
355                                        temp = unicode(text, format)
356                                except UnicodeError, detail:
357                                        # This always works
358                                        #
359                                        temp = unicode(text, 'iso-8859-15')
360                                except LookupError, detail:
361                                        #text = 'ERROR: Could not find charset: %s, please install' %format
362                                        #temp = unicode(text, 'iso-8859-15')
363                                        temp = message_str
364                                       
365                        else:
366                                temp = string.strip(text)
367                                temp = unicode(text, 'iso-8859-15')
368
369                        if s:
370                                s = '%s %s' %(s, temp)
371                        else:
372                                s = '%s' %temp
373
374                #s = s.encode('utf-8')
375                return s
376
377
378        def email_header_txt(self, m):
379                """
380                Display To and CC addresses in description field
381                """
382                s = ''
383                #if m['To'] and len(m['To']) > 0 and m['To'] != 'hic@sara.nl':
384                if m['To'] and len(m['To']) > 0:
385                        s = "'''To:''' %s\r\n" %(m['To'])
386                if m['Cc'] and len(m['Cc']) > 0:
387                        s = "%s'''Cc:''' %s\r\n" % (s, m['Cc'])
388
389                return  self.email_to_unicode(s)
390
391
392        def get_sender_info(self, message):
393                """
394                Get the default author name and email address from the message
395                """
396
397                self.email_to = self.email_to_unicode(message['to'])
398                self.to_name, self.to_email_addr = email.Utils.parseaddr (self.email_to)
399
400                self.email_from = self.email_to_unicode(message['from'])
401                self.email_name, self.email_addr  = email.Utils.parseaddr(self.email_from)
402
403                ## Trac can not handle author's name that contains spaces
404                #  and forbid the ticket email address as author field
405
406                if self.email_addr == self.trac_smtp_from:
407                        self.author = "email2trac"
408                else:
409                        self.author = self.email_addr
410
411                if self.IGNORE_TRAC_USER_SETTINGS:
412                        return
413
414                # Is this a registered user, use email address as search key:
415                # result:
416                #   u : login name
417                #   n : Name that the user has set in the settings tab
418                #   e : email address that the user has set in the settings tab
419                #
420                users = [ (u,n,e) for (u, n, e) in self.env.get_known_users(self.db)
421                        if e and (e.lower() == self.email_addr.lower()) ]
422
423                if len(users) == 1:
424                        self.email_from = users[0][0]
425                        self.author = users[0][0]
426
427        def set_reply_fields(self, ticket, message):
428                """
429                Set all the right fields for a new ticket
430                """
431                if self.DEBUG:
432                        print 'TD: set_reply_fields'
433
434                ## Only use name or email adress
435                #ticket['reporter'] = self.email_from
436                ticket['reporter'] = self.author
437
438
439                # Put all CC-addresses in ticket CC field
440                #
441                if self.REPLY_ALL:
442
443                        email_cc = ''
444
445                        cc_addrs = email.Utils.getaddresses( message.get_all('cc', []) )
446
447                        if not cc_addrs:
448                                return
449
450                        ## Build a list of forbidden CC addresses
451                        #
452                        #to_addrs = email.Utils.getaddresses( message.get_all('to', []) )
453                        #to_list = list()
454                        #for n,e in to_addrs:
455                        #       to_list.append(e)
456                               
457                        # Remove reporter email address if notification is
458                        # on
459                        #
460                        if self.notification:
461                                try:
462                                        cc_addrs.remove((self.author, self.email_addr))
463                                except ValueError, detail:
464                                        pass
465
466                        for name,addr in cc_addrs:
467               
468                                ## Prevent mail loop
469                                #
470                                #if addr in to_list:
471
472                                if addr == self.trac_smtp_from:
473                                        if self.DEBUG:
474                                                print "Skipping %s mail address for CC-field" %(addr)
475                                        continue
476
477                                if email_cc:
478                                        email_cc = '%s, %s' %(email_cc, addr)
479                                else:
480                                        email_cc = addr
481
482                        if email_cc:
483                                if self.DEBUG:
484                                        print 'TD: set_reply_fields: %s' %email_cc
485
486                                ticket['cc'] = self.email_to_unicode(email_cc)
487
488        def debug_body(self, message_body, tempfile=False):
489                if tempfile:
490                        import tempfile
491                        body_file = tempfile.mktemp('.email2trac')
492                else:
493                        body_file = os.path.join(self.TMPDIR, 'body.txt')
494
495                print 'TD: writing body (%s)' % body_file
496                fx = open(body_file, 'wb')
497                if not message_body:
498                        message_body = '(None)'
499
500                message_body = message_body.encode('utf-8')
501                #message_body = unicode(message_body, 'iso-8859-15')
502
503                fx.write(message_body)
504                fx.close()
505                try:
506                        os.chmod(body_file,S_IRWXU|S_IRWXG|S_IRWXO)
507                except OSError:
508                        pass
509
510        def debug_attachments(self, message_parts):
511                n = 0
512                for part in message_parts:
513                        # Skip inline text parts
514                        if not isinstance(part, tuple):
515                                continue
516                               
517                        (original, filename, part) = part
518
519                        n = n + 1
520                        print 'TD: part%d: Content-Type: %s' % (n, part.get_content_type())
521                        print 'TD: part%d: filename: %s' % (n, part.get_filename())
522
523                        part_file = os.path.join(self.TMPDIR, filename)
524                        #part_file = '/var/tmp/part%d' % n
525                        print 'TD: writing part%d (%s)' % (n,part_file)
526                        fx = open(part_file, 'wb')
527                        text = part.get_payload(decode=1)
528                        if not text:
529                                text = '(None)'
530                        fx.write(text)
531                        fx.close()
532                        try:
533                                os.chmod(part_file,S_IRWXU|S_IRWXG|S_IRWXO)
534                        except OSError:
535                                pass
536
537        def save_email_for_debug(self, message, tempfile=False):
538
539                if tempfile:
540                        import tempfile
541                        msg_file = tempfile.mktemp('.email2trac')
542                else:
543                        #msg_file = '/var/tmp/msg.txt'
544                        msg_file = os.path.join(self.TMPDIR, 'msg.txt')
545
546                print 'TD: saving email to %s' % msg_file
547                fx = open(msg_file, 'wb')
548                fx.write('%s' % message)
549                fx.close()
550                try:
551                        os.chmod(msg_file,S_IRWXU|S_IRWXG|S_IRWXO)
552                except OSError:
553                        pass
554
555                message_parts = self.get_message_parts(message)
556                message_parts = self.unique_attachment_names(message_parts)
557                body_text = self.body_text(message_parts)
558                self.debug_body(body_text, True)
559                self.debug_attachments(message_parts)
560
561        def str_to_dict(self, s):
562                """
563                Transfrom a string of the form [<key>=<value>]+ to dict[<key>] = <value>
564                """
565
566                fields = string.split(s, self.SUBJECT_FIELD_SEPARATOR)
567
568                result = dict()
569                for field in fields:
570                        try:
571                                index, value = string.split(field, '=')
572
573                                # We can not change the description of a ticket via the subject
574                                # line. The description is the body of the email
575                                #
576                                if index.lower() in ['description']:
577                                        continue
578
579                                if value:
580                                        result[index.lower()] = value
581
582                        except ValueError:
583                                pass
584                return result
585
586        def update_ticket_fields(self, ticket, user_dict, use_default=None):
587                """
588                This will update the ticket fields. It will check if the
589                given fields are known and if the right values are specified
590                It will only update the ticket field value:
591                        - If the field is known
592                        - If the value supplied is valid for the ticket field.
593                          If not then there are two options:
594                           1) Skip the value (use_default=None)
595                           2) Set default value for field (use_default=1)
596                """
597                if self.DEBUG:
598                        print "TD: update_ticket_fields"
599
600                # Build a system dictionary from the ticket fields
601                # with field as index and option as value
602                #
603                sys_dict = dict()
604                for field in ticket.fields:
605                        try:
606                                sys_dict[field['name']] = field['options']
607
608                        except KeyError:
609                                sys_dict[field['name']] = None
610                                pass
611
612                ## Check user supplied fields an compare them with the
613                # system one's
614                #
615                for field,value in user_dict.items():
616                        if self.DEBUG >= 10:
617                                print  'user_field\t %s = %s' %(field,value)
618
619                        ## To prevent mail loop
620                        #
621                        if field == 'cc':
622
623                                cc_list = user_dict['cc'].split(',')
624
625                                if self.trac_smtp_from in cc_list:
626                                        if self.DEBUG > 10:
627                                                print 'TD: MAIL LOOP: %s is not allowed as CC address' %(self.trac_smtp_from)
628                                        cc_list.remove(self.trac_smtp_from)
629
630                                value = ','.join(cc_list)
631                               
632
633                        if sys_dict.has_key(field):
634
635                                # Check if value is an allowed system option, if TypeError then
636                                # every value is allowed
637                                #
638                                try:
639                                        if value in sys_dict[field]:
640                                                ticket[field] = value
641                                        else:
642                                                # Must we set a default if value is not allowed
643                                                #
644                                                if use_default:
645                                                        value = self.get_config('ticket', 'default_%s' %(field) )
646                                                        ticket[field] = value
647
648                                except TypeError:
649                                        ticket[field] = value
650
651                                if self.DEBUG >= 10:
652                                        print  'ticket_field\t %s = %s' %(field,  ticket[field])
653                                       
654        def ticket_update(self, m, id, spam):
655                """
656                If the current email is a reply to an existing ticket, this function
657                will append the contents of this email to that ticket, instead of
658                creating a new one.
659                """
660                if self.DEBUG:
661                        print "TD: ticket_update: %s" %id
662
663                # Must we update ticket fields
664                #
665                update_fields = dict()
666                try:
667                        id, keywords = string.split(id, '?')
668
669                        # Skip the last ':' character
670                        #
671                        keywords = keywords[:-1]
672                        update_fields = self.str_to_dict(keywords)
673
674                        # Strip '#'
675                        #
676                        self.id = int(id[1:])
677
678                except ValueError:
679                        # Strip '#' and ':'
680                        #
681                        self.id = int(id[1:-1])
682
683
684                # When is the change committed
685                #
686                if self.VERSION == 0.11:
687                        utc = UTC()
688                        when = datetime.now(utc)
689                else:
690                        when = int(time.time())
691
692                try:
693                        tkt = Ticket(self.env, self.id, self.db)
694                except util.TracError, detail:
695                        # Not a valid ticket
696                        self.id = None
697                        return False
698
699                # How many changes has this ticket
700                cnum = len(tkt.get_changelog())
701
702
703                # reopen the ticket if it is was closed
704                # We must use the ticket workflow framework
705                #
706                if tkt['status'] in ['closed']:
707
708                        #print controller.actions['reopen']
709                        #
710                        # As reference 
711                        # req = Mock(href=Href('/'), abs_href=Href('http://www.example.com/'), authname='anonymous', perm=MockPerm(), args={})
712                        #
713                        #a = controller.render_ticket_action_control(req, tkt, 'reopen')
714                        #print 'controller : ', a
715                        #
716                        #b = controller.get_all_status()
717                        #print 'get all status: ', b
718                        #
719                        #b = controller.get_ticket_changes(req, tkt, 'reopen')
720                        #print 'get_ticket_changes :', b
721
722                        if self.WORKFLOW and (self.VERSION in [0.11]) :
723                                from trac.ticket.default_workflow import ConfigurableTicketWorkflow
724                                from trac.test import Mock, MockPerm
725
726                                req = Mock(authname='anonymous', perm=MockPerm(), args={})
727
728                                controller = ConfigurableTicketWorkflow(self.env)
729                                fields = controller.get_ticket_changes(req, tkt, self.WORKFLOW)
730
731                                if self.DEBUG:
732                                        print 'TD: Workflow ticket update fields: ', fields
733
734                                for key in fields.keys():
735                                        tkt[key] = fields[key]
736
737                        else:
738                                tkt['status'] = 'reopened'
739                                tkt['resolution'] = ''
740
741                # Must we update some ticket fields properties via subjectline
742                #
743                if update_fields:
744                        self.update_ticket_fields(tkt, update_fields)
745
746                message_parts = self.get_message_parts(m)
747                message_parts = self.unique_attachment_names(message_parts)
748
749                # Must we update some ticket fields properties via body_text
750                #
751                if self.properties:
752                                self.update_ticket_fields(tkt, self.properties)
753
754                if self.EMAIL_HEADER:
755                        message_parts.insert(0, self.email_header_txt(m))
756
757                body_text = self.body_text(message_parts)
758
759                if body_text.strip() or update_fields or self.properties:
760                        if self.DRY_RUN:
761                                print 'DRY_RUN: tkt.save_changes(self.author, body_text, ticket_change_number) ', self.author, cnum
762                        else:
763                                tkt.save_changes(self.author, body_text, when, None, str(cnum))
764                       
765
766                if self.VERSION  == 0.9:
767                        s = self.attachments(message_parts, True)
768                else:
769                        s = self.attachments(message_parts)
770
771                if self.notification and not spam:
772                        self.notify(tkt, False, when)
773
774                return True
775
776        def set_ticket_fields(self, ticket):
777                """
778                set the ticket fields to value specified
779                        - /etc/email2trac.conf with <prefix>_<field>
780                        - trac default values, trac.ini
781                """
782                user_dict = dict()
783
784                for field in ticket.fields:
785
786                        name = field['name']
787
788                        # skip some fields like resolution
789                        #
790                        if name in [ 'resolution' ]:
791                                continue
792
793                        # default trac value
794                        #
795                        if not field.get('custom'):
796                                value = self.get_config('ticket', 'default_%s' %(name) )
797                        else:
798                                value = field.get('value')
799                                options = field.get('options')
800                                if value and options and value not in options:
801                                        value = options[int(value)]
802
803                        if self.DEBUG > 10:
804                                print 'trac.ini name %s = %s' %(name, value)
805
806                        prefix = self.parameters['ticket_prefix']
807                        try:
808                                value = self.parameters['%s_%s' %(prefix, name)]
809                                if self.DEBUG > 10:
810                                        print 'email2trac.conf %s = %s ' %(name, value)
811
812                        except KeyError, detail:
813                                pass
814               
815                        if self.DEBUG:
816                                print 'user_dict[%s] = %s' %(name, value)
817
818                        user_dict[name] = value
819
820                self.update_ticket_fields(ticket, user_dict, use_default=1)
821
822                # Set status ticket
823                #`
824                ticket['status'] = 'new'
825
826
827
828        def new_ticket(self, msg, subject, spam, set_fields = None):
829                """
830                Create a new ticket
831                """
832                if self.DEBUG:
833                        print "TD: new_ticket"
834
835                tkt = Ticket(self.env)
836                self.set_ticket_fields(tkt)
837
838                # Old style setting for component, will be removed
839                #
840                if spam:
841                        tkt['component'] = 'Spam'
842
843                elif self.parameters.has_key('component'):
844                        tkt['component'] = self.parameters['component']
845
846                if not msg['Subject']:
847                        tkt['summary'] = u'(No subject)'
848                else:
849                        tkt['summary'] = subject
850
851                self.set_reply_fields(tkt, msg)
852
853                if set_fields:
854                        rest, keywords = string.split(set_fields, '?')
855
856                        if keywords:
857                                update_fields = self.str_to_dict(keywords)
858                                self.update_ticket_fields(tkt, update_fields)
859
860                # produce e-mail like header
861                #
862                head = ''
863                if self.EMAIL_HEADER > 0:
864                        head = self.email_header_txt(msg)
865
866                message_parts = self.get_message_parts(msg)
867
868                # Must we update some ticket fields properties via body_text
869                #
870                if self.properties:
871                                self.update_ticket_fields(tkt, self.properties)
872
873                if self.DEBUG:
874                        print 'TD: self.get_message_parts ',
875                        print message_parts
876
877                message_parts = self.unique_attachment_names(message_parts)
878                if self.DEBUG:
879                        print 'TD: self.unique_attachment_names',
880                        print message_parts
881               
882                if self.EMAIL_HEADER > 0:
883                        message_parts.insert(0, self.email_header_txt(msg))
884                       
885                body_text = self.body_text(message_parts)
886
887                tkt['description'] = body_text
888
889                #when = int(time.time())
890                #
891                utc = UTC()
892                when = datetime.now(utc)
893
894                if not self.DRY_RUN:
895                        self.id = tkt.insert()
896       
897                changed = False
898                comment = ''
899
900                # some routines in trac are dependend on ticket id     
901                # like alternate notify template
902                #
903                if self.notify_template:
904                        tkt['id'] = self.id
905                        changed = True
906
907                ## Rewrite the description if we have mailto enabled
908                #
909                if self.MAILTO:
910                        changed = True
911                        comment = u'\nadded mailto line\n'
912                        mailto = self.html_mailto_link( m['Subject'], body_text)
913
914                        tkt['description'] = u'%s\r\n%s%s\r\n' \
915                                %(head, mailto, body_text)
916       
917                ## Save the attachments to the ticket   
918                #
919                has_attachments =  self.attachments(message_parts)
920
921                #  Disabled
922                #if has_attachments:
923                #       changed = True
924                #       comment = '%s\n%s\n' %(comment, has_attachments)
925
926                if changed:
927                        if self.DRY_RUN:
928                                print 'DRY_RUN: tkt.save_changes(self.author, comment) ', self.author
929                        else:
930                                tkt.save_changes(self.author, comment)
931                                #print tkt.get_changelog(self.db, when)
932
933                if self.notification and not spam:
934                        self.notify(tkt, True)
935
936
937        def blog(self, id):
938                """
939                The blog create/update function
940                """
941                # import the modules
942                #
943                from tracfullblog.core import FullBlogCore
944                from tracfullblog.model import BlogPost, BlogCommen
945
946                # instantiate blog core
947                blog = FullBlogCore(self.env)
948                req = ''
949               
950                if id:
951
952                        # update blog
953                        #
954                        comment = BlogComment(self.env, id)
955                        comment.author = self.author
956                        comment.comment = self.get_body_text(m)
957                        blog.create_comment(req, comment)
958
959                else:
960                        # create blog
961                        #
962                        import time
963                        post = BlogPost(self.env, 'blog_'+time.strftime("%Y%m%d%H%M%S", time.gmtime()))
964
965                        #post = BlogPost(self.env, blog._get_default_postname(self.env))
966                       
967                        post.author = self.author
968                        post.title = self.email_to_unicode(m['Subject'])
969                        post.body = self.get_body_text(m)
970                       
971                        blog.create_post(req, post, self.author, u'Created by email2trac', False)
972
973        def save_message_for_debug(self):
974                """
975                Save the messages. So we can use it for debug purposes
976                """
977               
978
979        def parse(self, fp):
980                global m
981
982                m = email.message_from_file(fp)
983               
984                if not m:
985                        if self.DEBUG:
986                                print "TD: This is not a valid email message format"
987                        return
988                       
989                # Work around lack of header folding in Python; see http://bugs.python.org/issue4696
990                m.replace_header('Subject', m['Subject'].replace('\r', '').replace('\n', ''))
991
992                if self.DEBUG > 1:        # save the entire e-mail message text
993                        self.save_email_for_debug(m, True)
994
995                self.db = self.env.get_db_cnx()
996                self.get_sender_info(m)
997
998                if not self.email_header_acl('white_list', self.email_addr, True):
999                        if self.DEBUG > 1 :
1000                                print 'Message rejected : %s not in white list' %(self.email_addr)
1001                        return False
1002
1003                if self.email_header_acl('black_list', self.email_addr, False):
1004                        if self.DEBUG > 1 :
1005                                print 'Message rejected : %s in black list' %(self.email_addr)
1006                        return False
1007
1008                if not self.email_header_acl('recipient_list', self.to_email_addr, True):
1009                        if self.DEBUG > 1 :
1010                                print 'Message rejected : %s not in recipient list' %(self.to_email_addr)
1011                        return False
1012
1013                # If drop the message
1014                #
1015                if self.spam(m) == 'drop':
1016                        return False
1017
1018                elif self.spam(m) == 'spam':
1019                        spam_msg = True
1020                else:
1021                        spam_msg = False
1022
1023                if self.get_config('notification', 'smtp_enabled') in ['true']:
1024                        self.notification = 1
1025                else:
1026                        self.notification = 0
1027
1028
1029                # Check if  FullBlogPlugin is installed
1030                #
1031                blog_enabled = None
1032                if self.get_config('components', 'tracfullblog.*') in ['enabled']:
1033                        blog_enabled = True
1034                       
1035                if not m['Subject']:
1036                        return False
1037                else:
1038                        subject  = self.email_to_unicode(m['Subject'])         
1039
1040                #
1041                # [hic] #1529: Re: LRZ
1042                # [hic] #1529?owner=bas,priority=medium: Re: LRZ
1043                #
1044                TICKET_RE = re.compile(r"""
1045                        (?P<blog>blog:(?P<blog_id>\w*))
1046                        |(?P<new_fields>[#][?].*)
1047                        |(?P<reply>[#][\d]+:)
1048                        |(?P<reply_fields>[#][\d]+\?.*?:)
1049                        """, re.VERBOSE)
1050
1051                # Find out if this is a ticket or a blog
1052                #
1053                result =  TICKET_RE.search(subject)
1054
1055                if result:
1056                        if result.group('blog'):
1057                                if blog_enabled:
1058                                        self.blog(result.group('blog_id'))
1059                                else:
1060                                        if self.DEBUG:
1061                                                print "Fullblog plugin is not installed"
1062                                                return
1063
1064                        # update ticket + fields
1065                        #
1066                        if result.group('reply_fields') and self.TICKET_UPDATE:
1067                                self.ticket_update(m, result.group('reply_fields'), spam_msg)
1068
1069                        # Update ticket
1070                        #
1071                        elif result.group('reply') and self.TICKET_UPDATE:
1072                                self.ticket_update(m, result.group('reply'), spam_msg)
1073
1074                        # New ticket + fields
1075                        #
1076                        elif result.group('new_fields'):
1077                                self.new_ticket(m, subject[:result.start('new_fields')], spam_msg, result.group('new_fields'))
1078
1079                # Create ticket
1080                #
1081                else:
1082                        self.new_ticket(m, subject, spam_msg)
1083
1084        def strip_signature(self, text):
1085                """
1086                Strip signature from message, inspired by Mailman software
1087                """
1088                body = []
1089                for line in text.splitlines():
1090                        if line == '-- ':
1091                                break
1092                        body.append(line)
1093
1094                return ('\n'.join(body))
1095
1096        def reflow(self, text, delsp = 0):
1097                """
1098                Reflow the message based on the format="flowed" specification (RFC 3676)
1099                """
1100                flowedlines = []
1101                quotelevel = 0
1102                prevflowed = 0
1103
1104                for line in text.splitlines():
1105                        from re import match
1106                       
1107                        # Figure out the quote level and the content of the current line
1108                        m = match('(>*)( ?)(.*)', line)
1109                        linequotelevel = len(m.group(1))
1110                        line = m.group(3)
1111
1112                        # Determine whether this line is flowed
1113                        if line and line != '-- ' and line[-1] == ' ':
1114                                flowed = 1
1115                        else:
1116                                flowed = 0
1117
1118                        if flowed and delsp and line and line[-1] == ' ':
1119                                line = line[:-1]
1120
1121                        # If the previous line is flowed, append this line to it
1122                        if prevflowed and line != '-- ' and linequotelevel == quotelevel:
1123                                flowedlines[-1] += line
1124                        # Otherwise, start a new line
1125                        else:
1126                                flowedlines.append('>' * linequotelevel + line)
1127
1128                        prevflowed = flowed
1129                       
1130
1131                return '\n'.join(flowedlines)
1132
1133        def strip_quotes(self, text):
1134                """
1135                Strip quotes from message by Nicolas Mendoza
1136                """
1137                body = []
1138                for line in text.splitlines():
1139                        if line.startswith(self.EMAIL_QUOTE):
1140                                continue
1141                        body.append(line)
1142
1143                return ('\n'.join(body))
1144
1145        def inline_properties(self, text):
1146                """
1147                Parse text if we use inline keywords to set ticket fields
1148                """
1149                if self.DEBUG:
1150                        print 'TD: inline_properties function'
1151
1152                properties = dict()
1153                body = list()
1154
1155                INLINE_EXP = re.compile('\s*[@]\s*([a-zA-Z]+)\s*:(.*)$')
1156
1157                for line in text.splitlines():
1158                        match = INLINE_EXP.match(line)
1159                        if match:
1160                                keyword, value = match.groups()
1161                                self.properties[keyword] = value.strip()
1162                                if self.DEBUG:
1163                                        print "TD: inline properties: %s : %s" %(keyword,value)
1164                        else:
1165                                body.append(line)
1166                               
1167                return '\n'.join(body)
1168
1169
1170        def wrap_text(self, text, replace_whitespace = False):
1171                """
1172                Will break a lines longer then given length into several small
1173                lines of size given length
1174                """
1175                import textwrap
1176
1177                LINESEPARATOR = '\n'
1178                reformat = ''
1179
1180                for s in text.split(LINESEPARATOR):
1181                        tmp = textwrap.fill(s,self.USE_TEXTWRAP)
1182                        if tmp:
1183                                reformat = '%s\n%s' %(reformat,tmp)
1184                        else:
1185                                reformat = '%s\n' %reformat
1186
1187                return reformat
1188
1189                # Python2.4 and higher
1190                #
1191                #return LINESEPARATOR.join(textwrap.fill(s,width) for s in str.split(LINESEPARATOR))
1192                #
1193
1194
1195        def get_message_parts(self, msg):
1196                """
1197                parses the email message and returns a list of body parts and attachments
1198                body parts are returned as strings, attachments are returned as tuples of (filename, Message object)
1199                """
1200                message_parts = list()
1201       
1202                ALTERNATIVE_MULTIPART = False
1203
1204                for part in msg.walk():
1205                        if self.DEBUG:
1206                                print 'TD: Message part: Main-Type: %s' % part.get_content_maintype()
1207                                print 'TD: Message part: Content-Type: %s' % part.get_content_type()
1208
1209                        ## Check content type
1210                        #
1211                        if part.get_content_type() in self.STRIP_CONTENT_TYPES:
1212
1213                                if self.DEBUG:
1214                                        print "TD: A %s attachment named '%s' was skipped" %(part.get_content_type(), part.get_filename())
1215
1216                                continue
1217
1218                        ## Catch some mulitpart execptions
1219                        #
1220                        if part.get_content_type() == 'multipart/alternative':
1221                                ALTERNATIVE_MULTIPART = True
1222                                continue
1223
1224                        ## Skip multipart containers
1225                        #
1226                        if part.get_content_maintype() == 'multipart':
1227                                if self.DEBUG:
1228                                        print "TD: Skipping multipart container"
1229                                continue
1230                       
1231                        ## 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"
1232                        #
1233                        inline = self.inline_part(part)
1234
1235                        ## Drop HTML message
1236                        #
1237                        if ALTERNATIVE_MULTIPART and self.DROP_ALTERNATIVE_HTML_VERSION:
1238                                if part.get_content_type() == 'text/html':
1239                                        if self.DEBUG:
1240                                                print "TD: Skipping alternative HTML message"
1241
1242                                        ALTERNATIVE_MULTIPART = False
1243                                        continue
1244
1245                        ## Inline text parts are where the body is
1246                        #
1247                        if part.get_content_type() == 'text/plain' and inline:
1248                                if self.DEBUG:
1249                                        print 'TD:               Inline body part'
1250
1251                                # Try to decode, if fails then do not decode
1252                                #
1253                                body_text = part.get_payload(decode=1)
1254                                if not body_text:                       
1255                                        body_text = part.get_payload(decode=0)
1256
1257                                format = email.Utils.collapse_rfc2231_value(part.get_param('Format', 'fixed')).lower()
1258                                delsp = email.Utils.collapse_rfc2231_value(part.get_param('DelSp', 'no')).lower()
1259
1260                                if self.REFLOW and not self.VERBATIM_FORMAT and format == 'flowed':
1261                                        body_text = self.reflow(body_text, delsp == 'yes')
1262       
1263                                if self.STRIP_SIGNATURE:
1264                                        body_text = self.strip_signature(body_text)
1265
1266                                if self.STRIP_QUOTES:
1267                                        body_text = self.strip_quotes(body_text)
1268
1269                                if self.INLINE_PROPERTIES:
1270                                        body_text = self.inline_properties(body_text)
1271
1272                                if self.USE_TEXTWRAP:
1273                                        body_text = self.wrap_text(body_text)
1274
1275                                ## Get contents charset (iso-8859-15 if not defined in mail headers)
1276                                #
1277                                charset = part.get_content_charset()
1278                                if not charset:
1279                                        charset = 'iso-8859-15'
1280
1281                                try:
1282                                        ubody_text = unicode(body_text, charset)
1283
1284                                except UnicodeError, detail:
1285                                        ubody_text = unicode(body_text, 'iso-8859-15')
1286
1287                                except LookupError, detail:
1288                                        ubody_text = 'ERROR: Could not find charset: %s, please install' %(charset)
1289
1290                                if self.VERBATIM_FORMAT:
1291                                        message_parts.append('{{{\r\n%s\r\n}}}' %ubody_text)
1292                                else:
1293                                        message_parts.append('%s' %ubody_text)
1294                        else:
1295                                if self.DEBUG:
1296                                        print 'TD:               Filename: %s' % part.get_filename()
1297
1298                                message_parts.append((part.get_filename(), part))
1299
1300                return message_parts
1301               
1302        def unique_attachment_names(self, message_parts):
1303                """
1304                """
1305                renamed_parts = []
1306                attachment_names = set()
1307
1308                for part in message_parts:
1309                       
1310                        ## If not an attachment, leave it alone
1311                        #
1312                        if not isinstance(part, tuple):
1313                                renamed_parts.append(part)
1314                                continue
1315                               
1316                        (filename, part) = part
1317
1318                        ## If no filename, use a default one
1319                        #
1320                        if not filename:
1321                                filename = 'untitled-part'
1322
1323                                # Guess the extension from the content type, use non strict mode
1324                                # some additional non-standard but commonly used MIME types
1325                                # are also recognized
1326                                #
1327                                ext = mimetypes.guess_extension(part.get_content_type(), False)
1328                                if not ext:
1329                                        ext = '.bin'
1330
1331                                filename = '%s%s' % (filename, ext)
1332
1333# We now use the attachment insert function
1334#
1335                        ## Discard relative paths in attachment names
1336                        #
1337                        #filename = filename.replace('\\', '/').replace(':', '/')
1338                        #filename = os.path.basename(filename)
1339                        #
1340                        # We try to normalize the filename to utf-8 NFC if we can.
1341                        # Files uploaded from OS X might be in NFD.
1342                        # Check python version and then try it
1343                        #
1344                        #if sys.version_info[0] > 2 or (sys.version_info[0] == 2 and sys.version_info[1] >= 3):
1345                        #       try:
1346                        #               filename = unicodedata.normalize('NFC', unicode(filename, 'utf-8')).encode('utf-8') 
1347                        #       except TypeError:
1348                        #               pass
1349
1350                        # Make the filename unique for this ticket
1351                        num = 0
1352                        unique_filename = filename
1353                        dummy_filename, ext = os.path.splitext(filename)
1354
1355                        while unique_filename in attachment_names or self.attachment_exists(unique_filename):
1356                                num += 1
1357                                unique_filename = "%s-%s%s" % (dummy_filename, num, ext)
1358                               
1359                        if self.DEBUG:
1360                                print 'TD: Attachment with filename %s will be saved as %s' % (filename, unique_filename)
1361
1362                        attachment_names.add(unique_filename)
1363
1364                        renamed_parts.append((filename, unique_filename, part))
1365       
1366                return renamed_parts
1367                       
1368        def inline_part(self, part):
1369                return part.get_param('inline', None, 'Content-Disposition') == '' or not part.has_key('Content-Disposition')
1370               
1371                       
1372        def attachment_exists(self, filename):
1373
1374                if self.DEBUG:
1375                        print "TD: attachment_exists: Ticket number : %s, Filename : %s" %(self.id, filename)
1376
1377                # We have no valid ticket id
1378                #
1379                if not self.id:
1380                        return False
1381
1382                try:
1383                        att = attachment.Attachment(self.env, 'ticket', self.id, filename)
1384                        return True
1385                except attachment.ResourceNotFound:
1386                        return False
1387                       
1388        def body_text(self, message_parts):
1389                body_text = []
1390               
1391                for part in message_parts:
1392                        # Plain text part, append it
1393                        if not isinstance(part, tuple):
1394                                body_text.extend(part.strip().splitlines())
1395                                body_text.append("")
1396                                continue
1397                               
1398                        (original, filename, part) = part
1399                        inline = self.inline_part(part)
1400                       
1401                        if part.get_content_maintype() == 'image' and inline:
1402                                body_text.append('[[Image(%s)]]' % filename)
1403                                body_text.append("")
1404                        else:
1405                                body_text.append('[attachment:"%s"]' % filename)
1406                                body_text.append("")
1407                               
1408                body_text = '\r\n'.join(body_text)
1409                return body_text
1410
1411        def notify(self, tkt, new=True, modtime=0):
1412                """
1413                A wrapper for the TRAC notify function. So we can use templates
1414                """
1415                if self.DRY_RUN:
1416                                print 'DRY_RUN: self.notify(tkt, True) ', self.author
1417                                return
1418                try:
1419                        # create false {abs_}href properties, to trick Notify()
1420                        #
1421                        if not self.VERSION == 0.11:
1422                                self.env.abs_href = Href(self.get_config('project', 'url'))
1423                                self.env.href = Href(self.get_config('project', 'url'))
1424
1425                        tn = TicketNotifyEmail(self.env)
1426
1427                        if self.notify_template:
1428
1429                                if self.VERSION == 0.11:
1430
1431                                        from trac.web.chrome import Chrome
1432
1433                                        if self.notify_template_update and not new:
1434                                                tn.template_name = self.notify_template_update
1435                                        else:
1436                                                tn.template_name = self.notify_template
1437
1438                                        tn.template = Chrome(tn.env).load_template(tn.template_name, method='text')
1439                                               
1440                                else:
1441
1442                                        tn.template_name = self.notify_template;
1443
1444                        tn.notify(tkt, new, modtime)
1445
1446                except Exception, e:
1447                        print 'TD: Failure sending notification on creation of ticket #%s: %s' %(self.id, e)
1448
1449        def html_mailto_link(self, subject, body):
1450                """
1451                This function returns a HTML mailto tag with the ticket id and author email address
1452                """
1453                if not self.author:
1454                        author = self.email_addr
1455                else:   
1456                        author = self.author
1457
1458                # use urllib to escape the chars
1459                #
1460                s = 'mailto:%s?Subject=%s&Cc=%s' %(
1461                       urllib.quote(self.email_addr),
1462                           urllib.quote('Re: #%s: %s' %(self.id, subject)),
1463                           urllib.quote(self.MAILTO_CC)
1464                           )
1465
1466                s = '\r\n{{{\r\n#!html\r\n<a\r\n href="%s">Reply to: %s\r\n</a>\r\n}}}\r\n' %(s, author)
1467                return s
1468
1469        def attachments(self, message_parts, update=False):
1470                '''
1471                save any attachments as files in the ticket's directory
1472                '''
1473                if self.DRY_RUN:
1474                        print "DRY_RUN: no attachments saved"
1475                        return ''
1476
1477                count = 0
1478
1479                # Get Maxium attachment size
1480                #
1481                max_size = int(self.get_config('attachment', 'max_size'))
1482                status   = ''
1483               
1484                for part in message_parts:
1485                        # Skip body parts
1486                        if not isinstance(part, tuple):
1487                                continue
1488                               
1489                        (original, filename, part) = part
1490                        #
1491                        # Must be tuneables HvB
1492                        #
1493                        path, fd =  util.create_unique_file(os.path.join(self.TMPDIR, filename))
1494                        text = part.get_payload(decode=1)
1495                        if not text:
1496                                text = '(None)'
1497                        fd.write(text)
1498                        fd.close()
1499
1500                        # get the file_size
1501                        #
1502                        stats = os.lstat(path)
1503                        file_size = stats[stat.ST_SIZE]
1504
1505                        # Check if the attachment size is allowed
1506                        #
1507                        if (max_size != -1) and (file_size > max_size):
1508                                status = '%s\nFile %s is larger then allowed attachment size (%d > %d)\n\n' \
1509                                        %(status, original, file_size, max_size)
1510
1511                                os.unlink(path)
1512                                continue
1513                        else:
1514                                count = count + 1
1515                                       
1516                        # Insert the attachment
1517                        #
1518                        fd = open(path, 'rb')
1519                        att = attachment.Attachment(self.env, 'ticket', self.id)
1520
1521                        # This will break the ticket_update system, the body_text is vaporized
1522                        # ;-(
1523                        #
1524                        if not update:
1525                                att.author = self.author
1526                                att.description = self.email_to_unicode('Added by email2trac')
1527
1528                        att.insert(filename, fd, file_size)
1529
1530                        #except  util.TracError, detail:
1531                        #       print detail
1532
1533                        # Remove the created temporary filename
1534                        #
1535                        fd.close()
1536                        os.unlink(path)
1537
1538                # Return how many attachments
1539                #
1540                status = 'This message has %d attachment(s)\n%s' %(count, status)
1541                return status
1542
1543
1544def mkdir_p(dir, mode):
1545        '''do a mkdir -p'''
1546
1547        arr = string.split(dir, '/')
1548        path = ''
1549        for part in arr:
1550                path = '%s/%s' % (path, part)
1551                try:
1552                        stats = os.stat(path)
1553                except OSError:
1554                        os.mkdir(path, mode)
1555
1556def ReadConfig(file, name):
1557        """
1558        Parse the config file
1559        """
1560        if not os.path.isfile(file):
1561                print 'File %s does not exist' %file
1562                sys.exit(1)
1563
1564        config = trac_config.Configuration(file)
1565
1566        # Use given project name else use defaults
1567        #
1568        if name:
1569                sections = config.sections()
1570                if not name in sections:
1571                        print "Not a valid project name: %s" %name
1572                        print "Valid names: %s" %sections
1573                        sys.exit(1)
1574
1575                project =  dict()
1576                for option, value in  config.options(name):
1577                        project[option] = value
1578
1579        else:
1580                # use some trac internals to get the defaults
1581                #
1582                project = config.parser.defaults()
1583
1584        return project
1585
1586
1587if __name__ == '__main__':
1588        # Default config file
1589        #
1590        configfile = '@email2trac_conf@'
1591        project = ''
1592        component = ''
1593        ticket_prefix = 'default'
1594        dry_run = None
1595
1596        ENABLE_SYSLOG = 0
1597
1598
1599        SHORT_OPT = 'chf:np:t:'
1600        LONG_OPT  =  ['component=', 'dry-run', 'help', 'file=', 'project=', 'ticket_prefix=']
1601
1602        try:
1603                opts, args = getopt.getopt(sys.argv[1:], SHORT_OPT, LONG_OPT)
1604        except getopt.error,detail:
1605                print __doc__
1606                print detail
1607                sys.exit(1)
1608       
1609        project_name = None
1610        for opt,value in opts:
1611                if opt in [ '-h', '--help']:
1612                        print __doc__
1613                        sys.exit(0)
1614                elif opt in ['-c', '--component']:
1615                        component = value
1616                elif opt in ['-f', '--file']:
1617                        configfile = value
1618                elif opt in ['-n', '--dry-run']:
1619                        dry_run = True
1620                elif opt in ['-p', '--project']:
1621                        project_name = value
1622                elif opt in ['-t', '--ticket_prefix']:
1623                        ticket_prefix = value
1624       
1625        settings = ReadConfig(configfile, project_name)
1626        if not settings.has_key('project'):
1627                print __doc__
1628                print 'No Trac project is defined in the email2trac config file.'
1629                sys.exit(1)
1630       
1631        if component:
1632                settings['component'] = component
1633
1634        # The default prefix for ticket values in email2trac.conf
1635        #
1636        settings['ticket_prefix'] = ticket_prefix
1637        settings['dry_run'] = dry_run
1638       
1639        if settings.has_key('trac_version'):
1640                version = settings['trac_version']
1641        else:
1642                version = trac_default_version
1643
1644
1645        #debug HvB
1646        #print settings
1647
1648        try:
1649                if version == '0.9':
1650                        from trac import attachment
1651                        from trac.env import Environment
1652                        from trac.ticket import Ticket
1653                        from trac.web.href import Href
1654                        from trac import util
1655                        from trac.Notify import TicketNotifyEmail
1656                elif version == '0.10':
1657                        from trac import attachment
1658                        from trac.env import Environment
1659                        from trac.ticket import Ticket
1660                        from trac.web.href import Href
1661                        from trac import util
1662                        #
1663                        # return  util.text.to_unicode(str)
1664                        #
1665                        # see http://projects.edgewall.com/trac/changeset/2799
1666                        from trac.ticket.notification import TicketNotifyEmail
1667                        from trac import config as trac_config
1668                elif version == '0.11':
1669                        from trac import attachment
1670                        from trac.env import Environment
1671                        from trac.ticket import Ticket
1672                        from trac.web.href import Href
1673                        from trac import config as trac_config
1674                        from trac import util
1675
1676
1677                        #
1678                        # return  util.text.to_unicode(str)
1679                        #
1680                        # see http://projects.edgewall.com/trac/changeset/2799
1681                        from trac.ticket.notification import TicketNotifyEmail
1682                else:
1683                        print 'TRAC version %s is not supported' %version
1684                        sys.exit(1)
1685                       
1686                if settings.has_key('enable_syslog'):
1687                        if SYSLOG_AVAILABLE:
1688                                ENABLE_SYSLOG =  float(settings['enable_syslog'])
1689
1690
1691                # Must be set before environment is created
1692                #
1693                if settings.has_key('python_egg_cache'):
1694                        python_egg_cache = str(settings['python_egg_cache'])
1695                        os.environ['PYTHON_EGG_CACHE'] = python_egg_cache
1696
1697                env = Environment(settings['project'], create=0)
1698                tktparser = TicketEmailParser(env, settings, float(version))
1699                tktparser.parse(sys.stdin)
1700
1701        # Catch all errors ans log to SYSLOG if we have enabled this
1702        # else stdout
1703        #
1704        except Exception, error:
1705                if ENABLE_SYSLOG:
1706                        syslog.openlog('email2trac', syslog.LOG_NOWAIT)
1707
1708                        etype, evalue, etb = sys.exc_info()
1709                        for e in traceback.format_exception(etype, evalue, etb):
1710                                syslog.syslog(e)
1711
1712                        syslog.closelog()
1713                else:
1714                        traceback.print_exc()
1715
1716                if m:
1717                        tktparser.save_email_for_debug(m, True)
1718
1719                sys.exit(1)
1720# EOB
Note: See TracBrowser for help on using the repository browser.