source: trunk/email2trac.py.in @ 329

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

Really fixed the bug when subject is not set

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