Context Navigation

source: trunk/email2trac.py.in @ 378

Last change on this file since 378 was 378, checked in by bas, 14 years ago
email2trac.py.in, fixed some unciode errors when debug is enabled, see #205
Property svn:executable set to ``* Property svn:keywords set to `Id`
File size: 55.3 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	"""
23	email2trac.py -- Email tickets to Trac.
24
25	A simple MTA filter to create Trac tickets from inbound emails.
26
27	Copyright 2005, Daniel Lundin <daniel@edgewall.com>
28	Copyright 2005, Edgewall Software
29
30	Authors:
31	Bas van der Vlies <basv@sara.nl>
32	Walter de Jong <walter@sara.nl>
33
34	The scripts reads emails from stdin and inserts directly into a Trac database.
35
36	How to use
37	----------
38	* See https://subtrac.sara.nl/oss/email2trac/
39
40	* Create an config file:
41	[DEFAULT] # REQUIRED
42	project : /data/trac/test # REQUIRED
43	debug : 1 # OPTIONAL, if set print some DEBUG info
44
45	[jouvin] # OPTIONAL project declaration, if set both fields necessary
46	project : /data/trac/jouvin # use -p\|--project jouvin.
47
48	* default config file is : /etc/email2trac.conf
49
50	* Commandline opions:
51	-h,--help
52	-f,--file <configuration file>
53	-n,--dry-run
54	-p, --project <project name>
55	-t, --ticket_prefix <name>
56
57	SVN Info:
58	$Id: email2trac.py.in 378 2010-06-22 09:21:22Z bas $
59	"""
60	import os
61	import sys
62	import string
63	import getopt
64	import stat
65	import time
66	import email
67	import email.Iterators
68	import email.Header
69	import re
70	import urllib
71	import unicodedata
72	from stat import *
73	import mimetypes
74	import traceback
75
76	from trac import __version__ as trac_version
77
78	# Will fail where unavailable, e.g. Windows
79	#
80	try:
81	import syslog
82	SYSLOG_AVAILABLE = True
83	except ImportError:
84	SYSLOG_AVAILABLE = False
85
86	from datetime import tzinfo, timedelta, datetime
87	from trac import config as trac_config
88
89	# Some global variables
90	#
91	trac_default_version = '0.11'
92	m = None
93
94	# A UTC class needed for trac version 0.11, added by
95	# tbaschak at ktc dot mb dot ca
96	#
97	class 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
112	class 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	self.VERBOSE = parameters['verbose']
140
141	self.get_config = self.env.config.get
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'])
153	if parameters.has_key('mailto_cc'):
154	self.MAILTO_CC = parameters['mailto_cc']
155	else:
156	self.MAILTO_CC = ''
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
165	if parameters.has_key('spam_header'):
166	self.SPAM_HEADER = parameters['spam_header']
167	else:
168	self.SPAM_HEADER = 'X-Spam-Score'
169
170	if parameters.has_key('email_quote'):
171	self.EMAIL_QUOTE = str(parameters['email_quote'])
172	else:
173	self.EMAIL_QUOTE = '> '
174
175	if parameters.has_key('email_header'):
176	self.EMAIL_HEADER = int(parameters['email_header'])
177	else:
178	self.EMAIL_HEADER = 0
179
180	if parameters.has_key('alternate_notify_template'):
181	self.notify_template = str(parameters['alternate_notify_template'])
182	else:
183	self.notify_template = None
184
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
190	if parameters.has_key('reply_all'):
191	self.REPLY_ALL = int(parameters['reply_all'])
192	else:
193	self.REPLY_ALL = 0
194
195	if parameters.has_key('ticket_update'):
196	self.TICKET_UPDATE = int(parameters['ticket_update'])
197	else:
198	self.TICKET_UPDATE = 0
199
200	if parameters.has_key('ticket_update_by_subject'):
201	self.TICKET_UPDATE_BY_SUBJECT = int(parameters['ticket_update_by_subject'])
202	else:
203	self.TICKET_UPDATE_BY_SUBJECT = 0
204
205	if parameters.has_key('ticket_update_by_subject_lookback'):
206	self.TICKET_UPDATE_BY_SUBJECT_LOOKBACK = int(parameters['ticket_update_by_subject_lookback'])
207	else:
208	self.TICKET_UPDATE_BY_SUBJECT_LOOKBACK = 30
209
210	if parameters.has_key('drop_spam'):
211	self.DROP_SPAM = int(parameters['drop_spam'])
212	else:
213	self.DROP_SPAM = 0
214
215	if parameters.has_key('verbatim_format'):
216	self.VERBATIM_FORMAT = int(parameters['verbatim_format'])
217	else:
218	self.VERBATIM_FORMAT = 1
219
220	if parameters.has_key('reflow'):
221	self.REFLOW = int(parameters['reflow'])
222	else:
223	self.REFLOW = 1
224
225	if parameters.has_key('drop_alternative_html_version'):
226	self.DROP_ALTERNATIVE_HTML_VERSION = int(parameters['drop_alternative_html_version'])
227	else:
228	self.DROP_ALTERNATIVE_HTML_VERSION = 0
229
230	if parameters.has_key('strip_signature'):
231	self.STRIP_SIGNATURE = int(parameters['strip_signature'])
232	else:
233	self.STRIP_SIGNATURE = 0
234
235	if parameters.has_key('strip_quotes'):
236	self.STRIP_QUOTES = int(parameters['strip_quotes'])
237	else:
238	self.STRIP_QUOTES = 0
239
240	self.properties = dict()
241	if parameters.has_key('inline_properties'):
242	self.INLINE_PROPERTIES = int(parameters['inline_properties'])
243	else:
244	self.INLINE_PROPERTIES = 0
245
246	if parameters.has_key('use_textwrap'):
247	self.USE_TEXTWRAP = int(parameters['use_textwrap'])
248	else:
249	self.USE_TEXTWRAP = 0
250
251	if parameters.has_key('binhex'):
252	self.STRIP_CONTENT_TYPES.append('application/mac-binhex40')
253
254	if parameters.has_key('applesingle'):
255	self.STRIP_CONTENT_TYPES.append('application/applefile')
256
257	if parameters.has_key('appledouble'):
258	self.STRIP_CONTENT_TYPES.append('application/applefile')
259
260	if parameters.has_key('strip_content_types'):
261	items = parameters['strip_content_types'].split(',')
262	for item in items:
263	self.STRIP_CONTENT_TYPES.append(item.strip())
264
265	self.WORKFLOW = None
266	if parameters.has_key('workflow'):
267	self.WORKFLOW = parameters['workflow']
268
269	# Use OS independend functions
270	#
271	self.TMPDIR = os.path.normcase('/tmp')
272	if parameters.has_key('tmpdir'):
273	self.TMPDIR = os.path.normcase(str(parameters['tmpdir']))
274
275	if parameters.has_key('ignore_trac_user_settings'):
276	self.IGNORE_TRAC_USER_SETTINGS = int(parameters['ignore_trac_user_settings'])
277	else:
278	self.IGNORE_TRAC_USER_SETTINGS = 0
279
280	if parameters.has_key('email_triggers_workflow'):
281	self.EMAIL_TRIGGERS_WORKFLOW = int(parameters['email_triggers_workflow'])
282	else:
283	self.EMAIL_TRIGGERS_WORKFLOW = 1
284
285	if parameters.has_key('subject_field_separator'):
286	self.SUBJECT_FIELD_SEPARATOR = parameters['subject_field_separator'].strip()
287	else:
288	self.SUBJECT_FIELD_SEPARATOR = '&'
289
290	self.trac_smtp_from = self.get_config('notification', 'smtp_from')
291
292	self.system = None
293
294	########## Email Header Functions ###########################################################
295
296	def spam(self, message):
297	"""
298	# X-Spam-Score: *** (3.255) BAYES_50,DNS_FROM_AHBL_RHSBL,HTML_
299	# Note if Spam_level then '*' are included
300	"""
301	spam = False
302	if message.has_key(self.SPAM_HEADER):
303	spam_l = string.split(message[self.SPAM_HEADER])
304
305	try:
306	number = spam_l[0].count('*')
307	except IndexError, detail:
308	number = 0
309
310	if number >= self.SPAM_LEVEL:
311	spam = True
312
313	# treat virus mails as spam
314	#
315	elif message.has_key('X-Virus-found'):
316	spam = True
317
318	# How to handle SPAM messages
319	#
320	if self.DROP_SPAM and spam:
321	if self.DEBUG > 2 :
322	print 'This message is a SPAM. Automatic ticket insertion refused (SPAM level > %d' % self.SPAM_LEVEL
323
324	return 'drop'
325
326	elif spam:
327
328	return 'Spam'
329
330	else:
331
332	return False
333
334	def email_header_acl(self, keyword, header_field, default):
335	"""
336	This function wil check if the email address is allowed or denied
337	to send mail to the ticket list
338	"""
339	try:
340	mail_addresses = self.parameters[keyword]
341
342	# Check if we have an empty string
343	#
344	if not mail_addresses:
345	return default
346
347	except KeyError, detail:
348	if self.DEBUG > 2 :
349	print 'TD: %s not defined, all messages are allowed.' %(keyword)
350
351	return default
352
353	mail_addresses = string.split(mail_addresses, ',')
354
355	for entry in mail_addresses:
356	entry = entry.strip()
357	TO_RE = re.compile(entry, re.VERBOSE\|re.IGNORECASE)
358	result = TO_RE.search(header_field)
359	if result:
360	return True
361
362	return False
363
364	def email_header_txt(self, m):
365	"""
366	Display To and CC addresses in description field
367	"""
368	s = ''
369
370	if m['To'] and len(m['To']) > 0:
371	s = "'''To:''' %s\r\n" %(m['To'])
372	if m['Cc'] and len(m['Cc']) > 0:
373	s = "%s'''Cc:''' %s\r\n" % (s, m['Cc'])
374
375	return self.email_to_unicode(s)
376
377
378	def get_sender_info(self, message):
379	"""
380	Get the default author name and email address from the message
381	"""
382
383	self.email_to = self.email_to_unicode(message['to'])
384	self.to_name, self.to_email_addr = email.Utils.parseaddr (self.email_to)
385
386	self.email_from = self.email_to_unicode(message['from'])
387	self.email_name, self.email_addr = email.Utils.parseaddr(self.email_from)
388
389	## Trac can not handle author's name that contains spaces
390	# and forbid the ticket email address as author field
391
392	if self.email_addr == self.trac_smtp_from:
393	self.author = "email2trac"
394	else:
395	self.author = self.email_addr
396
397	if self.IGNORE_TRAC_USER_SETTINGS:
398	return
399
400	# Is this a registered user, use email address as search key:
401	# result:
402	# u : login name
403	# n : Name that the user has set in the settings tab
404	# e : email address that the user has set in the settings tab
405	#
406	users = [ (u,n,e) for (u, n, e) in self.env.get_known_users(self.db)
407	if e and (e.lower() == self.email_addr.lower()) ]
408
409	if len(users) == 1:
410	self.email_from = users[0][0]
411	self.author = users[0][0]
412
413	def set_reply_fields(self, ticket, message):
414	"""
415	Set all the right fields for a new ticket
416	"""
417	if self.DEBUG:
418	print 'TD: set_reply_fields'
419
420	## Only use name or email adress
421	#ticket['reporter'] = self.email_from
422	ticket['reporter'] = self.author
423
424
425	# Put all CC-addresses in ticket CC field
426	#
427	if self.REPLY_ALL:
428
429	email_cc = ''
430
431	cc_addrs = email.Utils.getaddresses( message.get_all('cc', []) )
432
433	if not cc_addrs:
434	return
435
436	## Build a list of forbidden CC addresses
437	#
438	#to_addrs = email.Utils.getaddresses( message.get_all('to', []) )
439	#to_list = list()
440	#for n,e in to_addrs:
441	# to_list.append(e)
442
443	# Remove reporter email address if notification is
444	# on
445	#
446	if self.notification:
447	try:
448	cc_addrs.remove((self.author, self.email_addr))
449	except ValueError, detail:
450	pass
451
452	for name,addr in cc_addrs:
453
454	## Prevent mail loop
455	#
456	#if addr in to_list:
457
458	if addr == self.trac_smtp_from:
459	if self.DEBUG:
460	print "Skipping %s mail address for CC-field" %(addr)
461	continue
462
463	if email_cc:
464	email_cc = '%s, %s' %(email_cc, addr)
465	else:
466	email_cc = addr
467
468	if email_cc:
469	if self.DEBUG:
470	print 'TD: set_reply_fields: %s' %email_cc
471
472	ticket['cc'] = self.email_to_unicode(email_cc)
473
474
475	########## DEBUG functions ###########################################################
476
477	def debug_body(self, message_body, tempfile=False):
478	if tempfile:
479	import tempfile
480	body_file = tempfile.mktemp('.email2trac')
481	else:
482	body_file = os.path.join(self.TMPDIR, 'body.txt')
483
484	if self.DRY_RUN:
485	print 'DRY-RUN: not saving body to %s' %(body_file)
486	return
487
488	print 'TD: writing body to %s' %(body_file)
489	fx = open(body_file, 'wb')
490	if not message_body:
491	message_body = '(None)'
492
493	message_body = message_body.encode('utf-8')
494	#message_body = unicode(message_body, 'iso-8859-15')
495
496	fx.write(message_body)
497	fx.close()
498	try:
499	os.chmod(body_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
500	except OSError:
501	pass
502
503	def debug_attachments(self, message_parts):
504	"""
505	"""
506	if self.VERBOSE:
507	print "VB: debug_attachments"
508
509	n = 0
510	for item in message_parts:
511	# Skip inline text parts
512	if not isinstance(item, tuple):
513	continue
514
515	(original, filename, part) = item
516
517	n = n + 1
518	print 'TD: part%d: Content-Type: %s' % (n, part.get_content_type())
519
520	try:
521	print 'TD: part%d: filename: %s' % (n, filename)
522	except UnicodeEncodeError, detail:
523	print 'TD: part%d: filename: %s' % (n, util.text.unicode_quote(filename))
524
525	## Forbidden chars
526	#
527	filename = filename.replace('\\', '_')
528	filename = filename.replace('/', '_')
529
530
531	part_file = os.path.join(self.TMPDIR, filename)
532	try:
533	print 'TD: writing part%d (%s)' % (n,part_file)
534	except UnicodeEncodeError, detail:
535	print 'TD: writing part%d (%s)' % (n, util.text.unicode_quote(part_file))
536
537	if self.DRY_RUN:
538	print 'DRY_RUN: NOT saving attachments'
539	continue
540
541	part_file = util.text.unicode_quote(part_file)
542
543	fx = open(part_file, 'wb')
544	text = part.get_payload(decode=1)
545
546	if not text:
547	text = '(None)'
548
549	fx.write(text)
550	fx.close()
551
552	try:
553	os.chmod(part_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
554	except OSError:
555	pass
556
557	def save_email_for_debug(self, message, tempfile=False):
558
559	if tempfile:
560	import tempfile
561	msg_file = tempfile.mktemp('.email2trac')
562	else:
563	#msg_file = '/var/tmp/msg.txt'
564	msg_file = os.path.join(self.TMPDIR, 'msg.txt')
565
566	if self.DRY_RUN:
567	print 'DRY_RUN: NOT saving email message to %s' %(msg_file)
568	else:
569	print 'TD: saving email to %s' %(msg_file)
570
571	fx = open(msg_file, 'wb')
572	fx.write('%s' % message)
573	fx.close()
574
575	try:
576	os.chmod(msg_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
577	except OSError:
578	pass
579
580	message_parts = self.get_message_parts(message)
581	message_parts = self.unique_attachment_names(message_parts)
582	body_text = self.body_text(message_parts)
583	self.debug_body(body_text, True)
584	self.debug_attachments(message_parts)
585
586	########## Conversion functions ###########################################################
587
588	def email_to_unicode(self, message_str):
589	"""
590	Email has 7 bit ASCII code, convert it to unicode with the charset
591	that is encoded in 7-bit ASCII code and encode it as utf-8 so Trac
592	understands it.
593	"""
594	if self.VERBOSE:
595	print "VB: email_to_unicode"
596
597
598
599	results = email.Header.decode_header(message_str)
600
601	s = None
602	for text,format in results:
603	if format:
604	try:
605	temp = unicode(text, format)
606	except UnicodeError, detail:
607	# This always works
608	#
609	temp = unicode(text, 'iso-8859-15')
610	except LookupError, detail:
611	#text = 'ERROR: Could not find charset: %s, please install' %format
612	#temp = unicode(text, 'iso-8859-15')
613	temp = message_str
614
615	else:
616	temp = string.strip(text)
617	temp = unicode(text, 'iso-8859-15')
618
619	if s:
620	s = '%s %s' %(s, temp)
621	else:
622	s = '%s' %temp
623
624	#s = s.encode('utf-8')
625	return s
626
627	def str_to_dict(self, s):
628	"""
629	Transfrom a string of the form [<key>=<value>]+ to dict[<key>] = <value>
630	"""
631	if self.VERBOSE:
632	print "VB: str_to_dict"
633
634	fields = string.split(s, self.SUBJECT_FIELD_SEPARATOR)
635
636	result = dict()
637	for field in fields:
638	try:
639	index, value = string.split(field, '=')
640
641	# We can not change the description of a ticket via the subject
642	# line. The description is the body of the email
643	#
644	if index.lower() in ['description']:
645	continue
646
647	if value:
648	result[index.lower()] = value
649
650	except ValueError:
651	pass
652	return result
653
654	########## TRAC ticket functions ###########################################################
655
656	def update_ticket_fields(self, ticket, user_dict, use_default=None):
657	"""
658	This will update the ticket fields. It will check if the
659	given fields are known and if the right values are specified
660	It will only update the ticket field value:
661	- If the field is known
662	- If the value supplied is valid for the ticket field.
663	If not then there are two options:
664	1) Skip the value (use_default=None)
665	2) Set default value for field (use_default=1)
666	"""
667	if self.VERBOSE:
668	print "VB: update_ticket_fields"
669
670	# Build a system dictionary from the ticket fields
671	# with field as index and option as value
672	#
673	sys_dict = dict()
674	for field in ticket.fields:
675	try:
676	sys_dict[field['name']] = field['options']
677
678	except KeyError:
679	sys_dict[field['name']] = None
680	pass
681
682	## Check user supplied fields an compare them with the
683	# system one's
684	#
685	for field,value in user_dict.items():
686	if self.DEBUG >= 10:
687	try:
688	print 'user_field\t %s = %s' %(field,value)
689	except UnicodeEncodeError, detail:
690	print 'user_field\t %s = %s' %(field, util.text.unicode_quote(value))
691
692	## To prevent mail loop
693	#
694	if field == 'cc':
695
696	cc_list = user_dict['cc'].split(',')
697
698	if self.trac_smtp_from in cc_list:
699	if self.DEBUG > 10:
700	print 'TD: MAIL LOOP: %s is not allowed as CC address' %(self.trac_smtp_from)
701	cc_list.remove(self.trac_smtp_from)
702
703	value = ','.join(cc_list)
704
705
706	if sys_dict.has_key(field):
707
708	# Check if value is an allowed system option, if TypeError then
709	# every value is allowed
710	#
711	try:
712	if value in sys_dict[field]:
713	ticket[field] = value
714	else:
715	# Must we set a default if value is not allowed
716	#
717	if use_default:
718	value = self.get_config('ticket', 'default_%s' %(field) )
719
720	except TypeError:
721	pass
722
723	## Only set if we have a value
724	#
725	if value:
726	ticket[field] = value
727
728	if self.DEBUG >= 10:
729	try:
730	print 'ticket_field\t %s = %s' %(field, ticket[field])
731	except UnicodeEncodeError, detail:
732	print 'ticket_field\t %s = %s' %(field, util.text.unicode_quote(ticket[field]))
733
734	def ticket_update(self, m, id, spam):
735	"""
736	If the current email is a reply to an existing ticket, this function
737	will append the contents of this email to that ticket, instead of
738	creating a new one.
739	"""
740	if self.VERBOSE:
741	print "VB: ticket_update: %s" %id
742
743	# Must we update ticket fields
744	#
745	update_fields = dict()
746	try:
747	id, keywords = string.split(id, '?')
748
749	# Skip the last ':' character
750	#
751	keywords = keywords[:-1]
752	update_fields = self.str_to_dict(keywords)
753
754	# Strip '#'
755	#
756	self.id = int(id[1:])
757
758	except ValueError:
759	# Strip '#'
760	#
761	self.id = int(id[1:])
762
763	if self.VERBOSE:
764	print "VB: ticket_update: %s" %id
765
766
767	# When is the change committed
768	#
769	if self.VERSION == 0.11:
770	utc = UTC()
771	when = datetime.now(utc)
772	else:
773	when = int(time.time())
774
775	try:
776	tkt = Ticket(self.env, self.id, self.db)
777	except util.TracError, detail:
778	# Not a valid ticket
779	self.id = None
780	return False
781
782	# How many changes has this ticket
783	cnum = len(tkt.get_changelog())
784
785
786	# reopen the ticket if it is was closed
787	# We must use the ticket workflow framework
788	#
789	if tkt['status'] in ['closed'] and self.EMAIL_TRIGGERS_WORKFLOW:
790
791	#print controller.actions['reopen']
792	#
793	# As reference
794	# req = Mock(href=Href('/'), abs_href=Href('http://www.example.com/'), authname='anonymous', perm=MockPerm(), args={})
795	#
796	#a = controller.render_ticket_action_control(req, tkt, 'reopen')
797	#print 'controller : ', a
798	#
799	#b = controller.get_all_status()
800	#print 'get all status: ', b
801	#
802	#b = controller.get_ticket_changes(req, tkt, 'reopen')
803	#print 'get_ticket_changes :', b
804
805	if self.WORKFLOW and (self.VERSION in [0.11]) :
806	from trac.ticket.default_workflow import ConfigurableTicketWorkflow
807	from trac.test import Mock, MockPerm
808
809	req = Mock(authname='anonymous', perm=MockPerm(), args={})
810
811	controller = ConfigurableTicketWorkflow(self.env)
812	fields = controller.get_ticket_changes(req, tkt, self.WORKFLOW)
813
814	if self.DEBUG:
815	print 'TD: Workflow ticket update fields: ', fields
816
817	for key in fields.keys():
818	tkt[key] = fields[key]
819
820	else:
821	tkt['status'] = 'reopened'
822	tkt['resolution'] = ''
823
824	# Must we update some ticket fields properties via subjectline
825	#
826	if update_fields:
827	self.update_ticket_fields(tkt, update_fields)
828
829	message_parts = self.get_message_parts(m)
830	message_parts = self.unique_attachment_names(message_parts)
831
832	# Must we update some ticket fields properties via body_text
833	#
834	if self.properties:
835	self.update_ticket_fields(tkt, self.properties)
836
837	if self.EMAIL_HEADER:
838	message_parts.insert(0, self.email_header_txt(m))
839
840	body_text = self.body_text(message_parts)
841
842	if self.VERSION == 0.9:
843	error_with_attachments = self.attach_attachments(message_parts, True)
844	else:
845	error_with_attachments = self.attach_attachments(message_parts)
846
847	if body_text.strip() or update_fields or self.properties:
848	if self.DRY_RUN:
849	print 'DRY_RUN: tkt.save_changes(self.author, body_text, ticket_change_number) ', self.author, cnum
850	else:
851	if error_with_attachments:
852	body_text = '%s\\%s' %(error_with_attachments, body_text)
853
854	tkt.save_changes(self.author, body_text, when, None, str(cnum))
855
856
857	#if self.VERSION == 0.9:
858	# error_with_attachments = self.attach_attachments(message_parts, True)
859	#else:
860	# error_with_attachments = self.attach_attachments(message_parts)
861
862	if self.notification and not spam:
863	self.notify(tkt, False, when)
864
865	return True
866
867	def set_ticket_fields(self, ticket):
868	"""
869	set the ticket fields to value specified
870	- /etc/email2trac.conf with <prefix>_<field>
871	- trac default values, trac.ini
872	"""
873	user_dict = dict()
874
875	for field in ticket.fields:
876
877	name = field['name']
878
879	## default trac value
880	#
881	if not field.get('custom'):
882	value = self.get_config('ticket', 'default_%s' %(name) )
883	else:
884	## Else we get the default value for reporter
885	#
886	value = field.get('value')
887	options = field.get('options')
888
889	if value and options and (value not in options):
890	value = options[int(value)]
891
892	if self.DEBUG > 10:
893	try:
894	print 'TD: trac.ini name %s = %s' %(name, value)
895	except UnicodeEncodeError, detail:
896	print 'TD: trac.ini name %s = %s' %(name, util.text.unicode_quote(value))
897
898	## email2trac.conf settings
899	#
900	prefix = self.parameters['ticket_prefix']
901	try:
902	value = self.parameters['%s_%s' %(prefix, name)]
903	if self.DEBUG > 10:
904	try:
905	print 'TD: email2trac.conf %s = %s ' %(name, value)
906	except UnicodeEncodeError, detail:
907	print 'TD: email2trac.conf %s = %s ' %(name, util.text.unicode_quote(value))
908
909	except KeyError, detail:
910	pass
911
912	if self.DEBUG:
913	try:
914	print 'user_dict[%s] = %s' %(name, value)
915	except UnicodeEncodeError, detail:
916	print 'user_dict[%s] = %s' %(name, util.text.unicode_quote(value))
917
918	if value:
919	user_dict[name] = value
920
921	self.update_ticket_fields(ticket, user_dict, use_default=1)
922
923	if 'status' not in user_dict.keys():
924	ticket['status'] = 'new'
925
926
927	def ticket_update_by_subject(self, subject):
928	"""
929	This list of Re: prefixes is probably incomplete. Taken from
930	wikipedia. Here is how the subject is matched
931	- Re: <subject>
932	- Re: (<Mail list label>:)+ <subject>
933
934	So we must have the last column
935	"""
936	if self.VERBOSE:
937	print "VB: ticket_update_by_subject()"
938
939	matched_id = None
940	if self.TICKET_UPDATE and self.TICKET_UPDATE_BY_SUBJECT:
941
942	SUBJECT_RE = re.compile(r'^(RE\|AW\|VS\|SV):(.:)\s(.)', re.IGNORECASE)
943	result = SUBJECT_RE.search(subject)
944
945	if result:
946	# This is a reply
947	orig_subject = result.group(3)
948
949	if self.DEBUG:
950	print 'TD: subject search string: %s' %(orig_subject)
951
952	cursor = self.db.cursor()
953	summaries = [orig_subject, '%%: %s' % orig_subject]
954
955	##
956	# Convert days to seconds
957	lookback = int(time.mktime(time.gmtime())) - \
958	self.TICKET_UPDATE_BY_SUBJECT_LOOKBACK * 24 * 3600
959
960
961	for summary in summaries:
962	if self.DEBUG:
963	print 'TD: Looking for summary matching: "%s"' % summary
964	sql = """SELECT id FROM ticket
965	WHERE changetime >= %s AND summary LIKE %s
966	ORDER BY changetime DESC"""
967	cursor.execute(sql, [lookback, summary.strip()])
968
969	for row in cursor:
970	(matched_id,) = row
971	if self.DEBUG:
972	print 'TD: Found matching ticket id: %d' % matched_id
973	break
974
975	if matched_id:
976	matched_id = '#%d' % matched_id
977	return matched_id
978
979	return matched_id
980
981
982	def new_ticket(self, msg, subject, spam, set_fields = None):
983	"""
984	Create a new ticket
985	"""
986	if self.VERBOSE:
987	print "VB: function new_ticket()"
988
989	tkt = Ticket(self.env)
990
991	self.set_reply_fields(tkt, msg)
992
993	self.set_ticket_fields(tkt)
994
995	# Old style setting for component, will be removed
996	#
997	if spam:
998	tkt['component'] = 'Spam'
999
1000	elif self.parameters.has_key('component'):
1001	tkt['component'] = self.parameters['component']
1002
1003	if not msg['Subject']:
1004	tkt['summary'] = u'(No subject)'
1005	else:
1006	tkt['summary'] = subject
1007
1008
1009	if set_fields:
1010	rest, keywords = string.split(set_fields, '?')
1011
1012	if keywords:
1013	update_fields = self.str_to_dict(keywords)
1014	self.update_ticket_fields(tkt, update_fields)
1015
1016	# produce e-mail like header
1017	#
1018	head = ''
1019	if self.EMAIL_HEADER > 0:
1020	head = self.email_header_txt(msg)
1021
1022	message_parts = self.get_message_parts(msg)
1023
1024	# Must we update some ticket fields properties via body_text
1025	#
1026	if self.properties:
1027	self.update_ticket_fields(tkt, self.properties)
1028
1029	if self.DEBUG:
1030	print 'TD: self.get_message_parts ',
1031	print message_parts
1032
1033	message_parts = self.unique_attachment_names(message_parts)
1034	if self.DEBUG:
1035	print 'TD: self.unique_attachment_names',
1036	print message_parts
1037
1038	if self.EMAIL_HEADER > 0:
1039	message_parts.insert(0, self.email_header_txt(msg))
1040
1041	body_text = self.body_text(message_parts)
1042
1043	tkt['description'] = body_text
1044
1045	#when = int(time.time())
1046	#
1047	utc = UTC()
1048	when = datetime.now(utc)
1049
1050	if not self.DRY_RUN:
1051	self.id = tkt.insert()
1052
1053	changed = False
1054	comment = ''
1055
1056	# some routines in trac are dependend on ticket id
1057	# like alternate notify template
1058	#
1059	if self.notify_template:
1060	tkt['id'] = self.id
1061	changed = True
1062
1063	## Rewrite the description if we have mailto enabled
1064	#
1065	if self.MAILTO:
1066	changed = True
1067	comment = u'\nadded mailto line\n'
1068	mailto = self.html_mailto_link( m['Subject'])
1069
1070	tkt['description'] = u'%s\r\n%s%s\r\n' \
1071	%(head, mailto, body_text)
1072
1073	## Save the attachments to the ticket
1074	#
1075	error_with_attachments = self.attach_attachments(message_parts)
1076
1077	if error_with_attachments:
1078	changed = True
1079	comment = '%s\n%s\n' %(comment, error_with_attachments)
1080
1081	if changed:
1082	if self.DRY_RUN:
1083	print 'DRY_RUN: tkt.save_changes(%s, comment) real reporter = %s' %( tkt['reporter'], self.author)
1084	else:
1085	tkt.save_changes(tkt['reporter'], comment)
1086	#print tkt.get_changelog(self.db, when)
1087
1088	if self.notification and not spam:
1089	self.notify(tkt, True)
1090
1091
1092	def attach_attachments(self, message_parts, update=False):
1093	'''
1094	save any attachments as files in the ticket's directory
1095	'''
1096	if self.VERBOSE:
1097	print "VB: attach_attachments()"
1098
1099	if self.DRY_RUN:
1100	print "DRY_RUN: no attachments attached to tickets"
1101	return ''
1102
1103	count = 0
1104
1105	# Get Maxium attachment size
1106	#
1107	max_size = int(self.get_config('attachment', 'max_size'))
1108	status = None
1109
1110	for item in message_parts:
1111	# Skip body parts
1112	if not isinstance(item, tuple):
1113	continue
1114
1115	(original, filename, part) = item
1116	#
1117	# We have to determine the size so we use this temporary solution. we must escape it
1118	# else we get UnicodeErrors.
1119	#
1120	path, fd = util.create_unique_file(os.path.join(self.TMPDIR, util.text.unicode_quote(filename)))
1121	text = part.get_payload(decode=1)
1122	if not text:
1123	text = '(None)'
1124	fd.write(text)
1125	fd.close()
1126
1127	# get the file_size
1128	#
1129	stats = os.lstat(path)
1130	file_size = stats[stat.ST_SIZE]
1131
1132	# Check if the attachment size is allowed
1133	#
1134	if (max_size != -1) and (file_size > max_size):
1135	status = '%s\nFile %s is larger then allowed attachment size (%d > %d)\n\n' \
1136	%(status, original, file_size, max_size)
1137
1138	os.unlink(path)
1139	continue
1140	else:
1141	count = count + 1
1142
1143	# Insert the attachment
1144	#
1145	fd = open(path, 'rb')
1146	if self.system == 'discussion':
1147	att = attachment.Attachment(self.env, 'discussion', 'topic/%s'
1148	% (self.id,))
1149	else:
1150	att = attachment.Attachment(self.env, 'ticket', self.id)
1151
1152	# This will break the ticket_update system, the body_text is vaporized
1153	# ;-(
1154	#
1155	if not update:
1156	att.author = self.author
1157	att.description = self.email_to_unicode('Added by email2trac')
1158
1159	try:
1160	att.insert(filename, fd, file_size)
1161	except OSError, detail:
1162	status = '%s\nFilename %s could not be saved, problem: %s' %(status, filename, detail)
1163
1164	# Remove the created temporary filename
1165	#
1166	fd.close()
1167	os.unlink(path)
1168
1169	## return error
1170	#
1171	return status
1172
1173	########## Fullblog functions #################################################
1174
1175	def blog(self, id):
1176	"""
1177	The blog create/update function
1178	"""
1179	# import the modules
1180	#
1181	from tracfullblog.core import FullBlogCore
1182	from tracfullblog.model import BlogPost, BlogComment
1183	from trac.test import Mock, MockPerm
1184
1185	# instantiate blog core
1186	blog = FullBlogCore(self.env)
1187	req = Mock(authname='anonymous', perm=MockPerm(), args={})
1188
1189	if id:
1190
1191	# update blog
1192	#
1193	comment = BlogComment(self.env, id)
1194	comment.author = self.author
1195
1196	message_parts = self.get_message_parts(m)
1197	comment.comment = self.body_text(message_parts)
1198
1199	blog.create_comment(req, comment)
1200
1201	else:
1202	# create blog
1203	#
1204	import time
1205	post = BlogPost(self.env, 'blog_'+time.strftime("%Y%m%d%H%M%S", time.gmtime()))
1206
1207	#post = BlogPost(self.env, blog._get_default_postname(self.env))
1208
1209	post.author = self.author
1210	post.title = self.email_to_unicode(m['Subject'])
1211
1212	message_parts = self.get_message_parts(m)
1213	post.body = self.body_text(message_parts)
1214
1215	blog.create_post(req, post, self.author, u'Created by email2trac', False)
1216
1217
1218	########## Discussion functions ##############################################
1219
1220	def discussion_topic(self, content, subject):
1221
1222	# Import modules.
1223	from tracdiscussion.api import DiscussionApi
1224	from trac.util.datefmt import to_timestamp, utc
1225
1226	if self.DEBUG:
1227	print 'TD: Creating a new topic in forum:', self.id
1228
1229	# Get dissussion API component.
1230	api = self.env[DiscussionApi]
1231	context = self._create_context(content, subject)
1232
1233	# Get forum for new topic.
1234	forum = api.get_forum(context, self.id)
1235
1236	if not forum and self.DEBUG:
1237	print 'ERROR: Replied forum doesn\'t exist'
1238
1239	# Prepare topic.
1240	topic = {'forum' : forum['id'],
1241	'subject' : context.subject,
1242	'time': to_timestamp(datetime.now(utc)),
1243	'author' : self.author,
1244	'subscribers' : [self.email_addr],
1245	'body' : self.body_text(context.content_parts)}
1246
1247	# Add topic to DB and commit it.
1248	self._add_topic(api, context, topic)
1249	self.db.commit()
1250
1251	def discussion_topic_reply(self, content, subject):
1252
1253	# Import modules.
1254	from tracdiscussion.api import DiscussionApi
1255	from trac.util.datefmt import to_timestamp, utc
1256
1257	if self.DEBUG:
1258	print 'TD: Replying to discussion topic', self.id
1259
1260	# Get dissussion API component.
1261	api = self.env[DiscussionApi]
1262	context = self._create_context(content, subject)
1263
1264	# Get replied topic.
1265	topic = api.get_topic(context, self.id)
1266
1267	if not topic and self.DEBUG:
1268	print 'ERROR: Replied topic doesn\'t exist'
1269
1270	# Prepare message.
1271	message = {'forum' : topic['forum'],
1272	'topic' : topic['id'],
1273	'replyto' : -1,
1274	'time' : to_timestamp(datetime.now(utc)),
1275	'author' : self.author,
1276	'body' : self.body_text(context.content_parts)}
1277
1278	# Add message to DB and commit it.
1279	self._add_message(api, context, message)
1280	self.db.commit()
1281
1282	def discussion_message_reply(self, content, subject):
1283
1284	# Import modules.
1285	from tracdiscussion.api import DiscussionApi
1286	from trac.util.datefmt import to_timestamp, utc
1287
1288	if self.DEBUG:
1289	print 'TD: Replying to discussion message', self.id
1290
1291	# Get dissussion API component.
1292	api = self.env[DiscussionApi]
1293	context = self._create_context(content, subject)
1294
1295	# Get replied message.
1296	message = api.get_message(context, self.id)
1297
1298	if not message and self.DEBUG:
1299	print 'ERROR: Replied message doesn\'t exist'
1300
1301	# Prepare message.
1302	message = {'forum' : message['forum'],
1303	'topic' : message['topic'],
1304	'replyto' : message['id'],
1305	'time' : to_timestamp(datetime.now(utc)),
1306	'author' : self.author,
1307	'body' : self.body_text(context.content_parts)}
1308
1309	# Add message to DB and commit it.
1310	self._add_message(api, context, message)
1311	self.db.commit()
1312
1313	def _create_context(self, content, subject):
1314
1315	# Import modules.
1316	from trac.mimeview import Context
1317	from trac.web.api import Request
1318	from trac.perm import PermissionCache
1319
1320	# TODO: Read server base URL from config.
1321	# Create request object to mockup context creation.
1322	#
1323	environ = {'SERVER_PORT' : 80,
1324	'SERVER_NAME' : 'test',
1325	'REQUEST_METHOD' : 'POST',
1326	'wsgi.url_scheme' : 'http',
1327	'wsgi.input' : sys.stdin}
1328	chrome = {'links': {},
1329	'scripts': [],
1330	'ctxtnav': [],
1331	'warnings': [],
1332	'notices': []}
1333
1334	if self.env.base_url_for_redirect:
1335	environ['trac.base_url'] = self.env.base_url
1336
1337	req = Request(environ, None)
1338	req.chrome = chrome
1339	req.tz = 'missing'
1340	req.authname = self.author
1341	req.perm = PermissionCache(self.env, self.author)
1342
1343	# Create and return context.
1344	context = Context.from_request(req)
1345	context.realm = 'discussion-email2trac'
1346	context.cursor = self.db.cursor()
1347	context.content = content
1348	context.subject = subject
1349
1350	# Read content parts from content.
1351	context.content_parts = self.get_message_parts(content)
1352	context.content_parts = self.unique_attachment_names(
1353	context.content_parts)
1354
1355	return context
1356
1357	def _add_topic(self, api, context, topic):
1358	context.req.perm.assert_permission('DISCUSSION_APPEND')
1359
1360	# Filter topic.
1361	for discussion_filter in api.discussion_filters:
1362	accept, topic_or_error = discussion_filter.filter_topic(
1363	context, topic)
1364	if accept:
1365	topic = topic_or_error
1366	else:
1367	raise TracError(topic_or_error)
1368
1369	# Add a new topic.
1370	api.add_topic(context, topic)
1371
1372	# Get inserted topic with new ID.
1373	topic = api.get_topic_by_time(context, topic['time'])
1374
1375	# Attach attachments.
1376	self.id = topic['id']
1377	self.attach_attachments(context.content_parts, self.VERSION == 0.9)
1378
1379	# Notify change listeners.
1380	for listener in api.topic_change_listeners:
1381	listener.topic_created(context, topic)
1382
1383	def _add_message(self, api, context, message):
1384	context.req.perm.assert_permission('DISCUSSION_APPEND')
1385
1386	# Filter message.
1387	for discussion_filter in api.discussion_filters:
1388	accept, message_or_error = discussion_filter.filter_message(
1389	context, message)
1390	if accept:
1391	message = message_or_error
1392	else:
1393	raise TracError(message_or_error)
1394
1395	# Add message.
1396	api.add_message(context, message)
1397
1398	# Get inserted message with new ID.
1399	message = api.get_message_by_time(context, message['time'])
1400
1401	# Attach attachments.
1402	self.id = message['topic']
1403	self.attach_attachments(context.content_parts, self.VERSION == 0.9)
1404
1405	# Notify change listeners.
1406	for listener in api.message_change_listeners:
1407	listener.message_created(context, message)
1408
1409	########## MAIN function ######################################################
1410
1411	def parse(self, fp):
1412	"""
1413	"""
1414	if self.VERBOSE:
1415	print "VB: main function parse()"
1416	global m
1417
1418	m = email.message_from_file(fp)
1419
1420	if not m:
1421	if self.DEBUG:
1422	print "TD: This is not a valid email message format"
1423	return
1424
1425	# Work around lack of header folding in Python; see http://bugs.python.org/issue4696
1426	try:
1427	m.replace_header('Subject', m['Subject'].replace('\r', '').replace('\n', ''))
1428	except AttributeError, detail:
1429	pass
1430
1431	if self.DEBUG > 1: # save the entire e-mail message text
1432	self.save_email_for_debug(m, True)
1433
1434	self.db = self.env.get_db_cnx()
1435	self.get_sender_info(m)
1436
1437	if not self.email_header_acl('white_list', self.email_addr, True):
1438	if self.DEBUG > 1 :
1439	print 'Message rejected : %s not in white list' %(self.email_addr)
1440	return False
1441
1442	if self.email_header_acl('black_list', self.email_addr, False):
1443	if self.DEBUG > 1 :
1444	print 'Message rejected : %s in black list' %(self.email_addr)
1445	return False
1446
1447	if not self.email_header_acl('recipient_list', self.to_email_addr, True):
1448	if self.DEBUG > 1 :
1449	print 'Message rejected : %s not in recipient list' %(self.to_email_addr)
1450	return False
1451
1452	# If drop the message
1453	#
1454	if self.spam(m) == 'drop':
1455	return False
1456
1457	elif self.spam(m) == 'spam':
1458	spam_msg = True
1459	else:
1460	spam_msg = False
1461
1462	if self.get_config('notification', 'smtp_enabled') in ['true']:
1463	self.notification = 1
1464	else:
1465	self.notification = 0
1466
1467	if not m['Subject']:
1468	subject = 'No Subject'
1469	else:
1470	subject = self.email_to_unicode(m['Subject'])
1471
1472	if self.DEBUG:
1473	print "TD:", subject
1474
1475	#
1476	# [hic] #1529: Re: LRZ
1477	# [hic] #1529?owner=bas,priority=medium: Re: LRZ
1478	#
1479	ticket_regex = r'''
1480	(?P<new_fields>[#][?].*)
1481	\|(?P<reply>(?P<id>[#][\d]+)(?P<fields>\?.?:))
1482	'''
1483	# Check if FullBlogPlugin is installed
1484	#
1485	blog_enabled = None
1486	blog_regex = ''
1487	if self.get_config('components', 'tracfullblog.*') in ['enabled']:
1488	blog_enabled = True
1489	blog_regex = '''\|(?P<blog>blog:(?P<blog_id>\w*))'''
1490
1491
1492	# Check if DiscussionPlugin is installed
1493	#
1494	discussion_enabled = None
1495	discussion_regex = ''
1496	if self.get_config('components', 'tracdiscussion.api.*') in ['enabled']:
1497	discussion_enabled = True
1498	discussion_regex = r'''
1499	\|(?P<forum>Forum[ ][#](?P<forum_id>\d+)[ ]-[ ]?)
1500	\|(?P<topic>Topic[ ][#](?P<topic_id>\d+)[ ]-[ ]?)
1501	\|(?P<message>Message[ ][#](?P<message_id>\d+)[ ]-[ ]?)
1502	'''
1503
1504
1505	regex_str = ticket_regex + blog_regex + discussion_regex
1506	SYSTEM_RE = re.compile(regex_str, re.VERBOSE)
1507
1508	# Find out if this is a ticket, a blog or a discussion
1509	#
1510	result = SYSTEM_RE.search(subject)
1511	if result:
1512	# update ticket + fields
1513	#
1514	if result.group('reply') and self.TICKET_UPDATE:
1515	self.system = 'ticket'
1516	self.ticket_update(m, result.group('reply'), spam_msg)
1517
1518	# New ticket + fields
1519	#
1520	elif result.group('new_fields'):
1521	self.system = 'ticket'
1522	self.new_ticket(m, subject[:result.start('new_fields')], spam_msg, result.group('new_fields'))
1523
1524	if blog_enabled:
1525	if result.group('blog'):
1526	self.system = 'blog'
1527	self.blog(result.group('blog_id'))
1528
1529	if discussion_enabled:
1530	# New topic.
1531	#
1532	if result.group('forum'):
1533	self.system = 'discussion'
1534	self.id = int(result.group('forum_id'))
1535	self.discussion_topic(m, subject[result.end('forum'):])
1536
1537	# Reply to topic.
1538	#
1539	elif result.group('topic'):
1540	self.system = 'discussion'
1541	self.id = int(result.group('topic_id'))
1542	self.discussion_topic_reply(m, subject[result.end('topic'):])
1543
1544	# Reply to topic message.
1545	#
1546	elif result.group('message'):
1547	self.system = 'discussion'
1548	self.id = int(result.group('message_id'))
1549	self.discussion_message_reply(m, subject[result.end('message'):])
1550
1551	else:
1552	self.system = 'ticket'
1553	result = self.ticket_update_by_subject(subject)
1554	if result:
1555	self.ticket_update(m, result, spam_msg)
1556	else:
1557	# No update by subject, so just create a new ticket
1558	self.new_ticket(m, subject, spam_msg)
1559
1560
1561	########## BODY TEXT functions ###########################################################
1562
1563	def strip_signature(self, text):
1564	"""
1565	Strip signature from message, inspired by Mailman software
1566	"""
1567	body = []
1568	for line in text.splitlines():
1569	if line == '-- ':
1570	break
1571	body.append(line)
1572
1573	return ('\n'.join(body))
1574
1575	def reflow(self, text, delsp = 0):
1576	"""
1577	Reflow the message based on the format="flowed" specification (RFC 3676)
1578	"""
1579	flowedlines = []
1580	quotelevel = 0
1581	prevflowed = 0
1582
1583	for line in text.splitlines():
1584	from re import match
1585
1586	# Figure out the quote level and the content of the current line
1587	m = match('(>)( ?)(.)', line)
1588	linequotelevel = len(m.group(1))
1589	line = m.group(3)
1590
1591	# Determine whether this line is flowed
1592	if line and line != '-- ' and line[-1] == ' ':
1593	flowed = 1
1594	else:
1595	flowed = 0
1596
1597	if flowed and delsp and line and line[-1] == ' ':
1598	line = line[:-1]
1599
1600	# If the previous line is flowed, append this line to it
1601	if prevflowed and line != '-- ' and linequotelevel == quotelevel:
1602	flowedlines[-1] += line
1603	# Otherwise, start a new line
1604	else:
1605	flowedlines.append('>' * linequotelevel + line)
1606
1607	prevflowed = flowed
1608
1609
1610	return '\n'.join(flowedlines)
1611
1612	def strip_quotes(self, text):
1613	"""
1614	Strip quotes from message by Nicolas Mendoza
1615	"""
1616	body = []
1617	for line in text.splitlines():
1618	if line.startswith(self.EMAIL_QUOTE):
1619	continue
1620	body.append(line)
1621
1622	return ('\n'.join(body))
1623
1624	def inline_properties(self, text):
1625	"""
1626	Parse text if we use inline keywords to set ticket fields
1627	"""
1628	if self.DEBUG:
1629	print 'TD: inline_properties function'
1630
1631	properties = dict()
1632	body = list()
1633
1634	INLINE_EXP = re.compile('\s[@]\s([a-zA-Z]+)\s:(.)$')
1635
1636	for line in text.splitlines():
1637	match = INLINE_EXP.match(line)
1638	if match:
1639	keyword, value = match.groups()
1640	self.properties[keyword] = value.strip()
1641	if self.DEBUG:
1642	print "TD: inline properties: %s : %s" %(keyword,value)
1643	else:
1644	body.append(line)
1645
1646	return '\n'.join(body)
1647
1648
1649	def wrap_text(self, text, replace_whitespace = False):
1650	"""
1651	Will break a lines longer then given length into several small
1652	lines of size given length
1653	"""
1654	import textwrap
1655
1656	LINESEPARATOR = '\n'
1657	reformat = ''
1658
1659	for s in text.split(LINESEPARATOR):
1660	tmp = textwrap.fill(s,self.USE_TEXTWRAP)
1661	if tmp:
1662	reformat = '%s\n%s' %(reformat,tmp)
1663	else:
1664	reformat = '%s\n' %reformat
1665
1666	return reformat
1667
1668	# Python2.4 and higher
1669	#
1670	#return LINESEPARATOR.join(textwrap.fill(s,width) for s in str.split(LINESEPARATOR))
1671	#
1672
1673	########## EMAIL attachements functions ###########################################################
1674
1675	def inline_part(self, part):
1676	"""
1677	"""
1678	if self.VERBOSE:
1679	print "VB: inline_part()"
1680
1681	return part.get_param('inline', None, 'Content-Disposition') == '' or not part.has_key('Content-Disposition')
1682
1683	def get_message_parts(self, msg):
1684	"""
1685	parses the email message and returns a list of body parts and attachments
1686	body parts are returned as strings, attachments are returned as tuples of (filename, Message object)
1687	"""
1688	if self.VERBOSE:
1689	print "VB: get_message_parts()"
1690
1691	message_parts = list()
1692
1693	ALTERNATIVE_MULTIPART = False
1694
1695	for part in msg.walk():
1696	if self.DEBUG:
1697	print 'TD: Message part: Main-Type: %s' % part.get_content_maintype()
1698	print 'TD: Message part: Content-Type: %s' % part.get_content_type()
1699
1700	## Check content type
1701	#
1702	if part.get_content_type() in self.STRIP_CONTENT_TYPES:
1703
1704	if self.DEBUG:
1705	print "TD: A %s attachment named '%s' was skipped" %(part.get_content_type(), part.get_filename())
1706
1707	continue
1708
1709	## Catch some mulitpart execptions
1710	#
1711	if part.get_content_type() == 'multipart/alternative':
1712	ALTERNATIVE_MULTIPART = True
1713	continue
1714
1715	## Skip multipart containers
1716	#
1717	if part.get_content_maintype() == 'multipart':
1718	if self.DEBUG:
1719	print "TD: Skipping multipart container"
1720	continue
1721
1722	## 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"
1723	#
1724	inline = self.inline_part(part)
1725
1726	## Drop HTML message
1727	#
1728	if ALTERNATIVE_MULTIPART and self.DROP_ALTERNATIVE_HTML_VERSION:
1729	if part.get_content_type() == 'text/html':
1730	if self.DEBUG:
1731	print "TD: Skipping alternative HTML message"
1732
1733	ALTERNATIVE_MULTIPART = False
1734	continue
1735
1736	## Inline text parts are where the body is
1737	#
1738	if part.get_content_type() == 'text/plain' and inline:
1739	if self.DEBUG:
1740	print 'TD: Inline body part'
1741
1742	# Try to decode, if fails then do not decode
1743	#
1744	body_text = part.get_payload(decode=1)
1745	if not body_text:
1746	body_text = part.get_payload(decode=0)
1747
1748	format = email.Utils.collapse_rfc2231_value(part.get_param('Format', 'fixed')).lower()
1749	delsp = email.Utils.collapse_rfc2231_value(part.get_param('DelSp', 'no')).lower()
1750
1751	if self.REFLOW and not self.VERBATIM_FORMAT and format == 'flowed':
1752	body_text = self.reflow(body_text, delsp == 'yes')
1753
1754	if self.STRIP_SIGNATURE:
1755	body_text = self.strip_signature(body_text)
1756
1757	if self.STRIP_QUOTES:
1758	body_text = self.strip_quotes(body_text)
1759
1760	if self.INLINE_PROPERTIES:
1761	body_text = self.inline_properties(body_text)
1762
1763	if self.USE_TEXTWRAP:
1764	body_text = self.wrap_text(body_text)
1765
1766	## Get contents charset (iso-8859-15 if not defined in mail headers)
1767	#
1768	charset = part.get_content_charset()
1769	if not charset:
1770	charset = 'iso-8859-15'
1771
1772	try:
1773	ubody_text = unicode(body_text, charset)
1774
1775	except UnicodeError, detail:
1776	ubody_text = unicode(body_text, 'iso-8859-15')
1777
1778	except LookupError, detail:
1779	ubody_text = 'ERROR: Could not find charset: %s, please install' %(charset)
1780
1781	if self.VERBATIM_FORMAT:
1782	message_parts.append('{{{\r\n%s\r\n}}}' %ubody_text)
1783	else:
1784	message_parts.append('%s' %ubody_text)
1785	else:
1786	if self.DEBUG:
1787	try:
1788	print 'TD: Filename: %s' % part.get_filename()
1789	except UnicodeEncodeError, detail:
1790	print 'TD: Filename: %s' % util.text.unicode_quote(part.get_filename())
1791
1792	##
1793	#
1794	filename = part.get_filename()
1795	message_parts.append((filename, part))
1796
1797	return message_parts
1798
1799	def unique_attachment_names(self, message_parts):
1800	"""
1801	"""
1802	renamed_parts = []
1803	attachment_names = set()
1804
1805	for item in message_parts:
1806
1807	## If not an attachment, leave it alone
1808	#
1809	if not isinstance(item, tuple):
1810	renamed_parts.append(item)
1811	continue
1812
1813	(filename, part) = item
1814
1815	## If no filename, use a default one
1816	#
1817	if not filename:
1818	filename = 'untitled-part'
1819
1820	# Guess the extension from the content type, use non strict mode
1821	# some additional non-standard but commonly used MIME types
1822	# are also recognized
1823	#
1824	ext = mimetypes.guess_extension(part.get_content_type(), False)
1825	if not ext:
1826	ext = '.bin'
1827
1828	filename = '%s%s' % (filename, ext)
1829
1830	## Discard relative paths for windows/unix in attachment names
1831	#
1832	#filename = filename.replace('\\', '/').replace(':', '/')
1833	filename = filename.replace('\\', '_')
1834	filename = filename.replace('/', '_')
1835
1836	#
1837	# We try to normalize the filename to utf-8 NFC if we can.
1838	# Files uploaded from OS X might be in NFD.
1839	# Check python version and then try it
1840	#
1841	#if sys.version_info[0] > 2 or (sys.version_info[0] == 2 and sys.version_info[1] >= 3):
1842	# try:
1843	# filename = unicodedata.normalize('NFC', unicode(filename, 'utf-8')).encode('utf-8')
1844	# except TypeError:
1845	# pass
1846
1847	# Make the filename unique for this ticket
1848	num = 0
1849	unique_filename = filename
1850	dummy_filename, ext = os.path.splitext(filename)
1851
1852	while (unique_filename in attachment_names) or self.attachment_exists(unique_filename):
1853	num += 1
1854	unique_filename = "%s-%s%s" % (dummy_filename, num, ext)
1855
1856	if self.DEBUG:
1857	try:
1858	print 'TD: Attachment with filename %s will be saved as %s' % (filename, unique_filename)
1859	except UnicodeEncodeError, detail:
1860	print 'Filename can not be printed due to non-ascii characters'
1861
1862	attachment_names.add(unique_filename)
1863
1864	renamed_parts.append((filename, unique_filename, part))
1865
1866	return renamed_parts
1867
1868
1869	def attachment_exists(self, filename):
1870
1871	if self.DEBUG:
1872	s = 'TD: attachment already exists: Id : '
1873	try:
1874	print "%s%s, Filename : %s" % (s, self.id, filename)
1875	except UnicodeEncodeError, detail:
1876	print "%s%s, Filename : Can not be printed due to non-ascii characters" %(s, self.id)
1877
1878	# We have no valid ticket id
1879	#
1880	if not self.id:
1881	return False
1882
1883	try:
1884	if self.system == 'discussion':
1885	att = attachment.Attachment(self.env, 'discussion', 'ticket/%s'
1886	% (self.id,), filename)
1887	else:
1888	att = attachment.Attachment(self.env, 'ticket', self.id,
1889	filename)
1890	return True
1891	except attachment.ResourceNotFound:
1892	return False
1893
1894	########## TRAC Ticket Text ###########################################################
1895
1896	def body_text(self, message_parts):
1897	body_text = []
1898
1899	for part in message_parts:
1900	# Plain text part, append it
1901	if not isinstance(part, tuple):
1902	body_text.extend(part.strip().splitlines())
1903	body_text.append("")
1904	continue
1905
1906	(original, filename, part) = part
1907	inline = self.inline_part(part)
1908
1909	if part.get_content_maintype() == 'image' and inline:
1910	if self.system != 'discussion':
1911	body_text.append('[[Image(%s)]]' % filename)
1912	body_text.append("")
1913	else:
1914	if self.system != 'discussion':
1915	body_text.append('[attachment:"%s"]' % filename)
1916	body_text.append("")
1917
1918	body_text = '\r\n'.join(body_text)
1919	return body_text
1920
1921	def html_mailto_link(self, subject):
1922	"""
1923	This function returns a HTML mailto tag with the ticket id and author email address
1924	"""
1925	if not self.author:
1926	author = self.email_addr
1927	else:
1928	author = self.author
1929
1930	# use urllib to escape the chars
1931	#
1932	s = 'mailto:%s?Subject=%s&Cc=%s' %(
1933	urllib.quote(self.email_addr),
1934	urllib.quote('Re: #%s: %s' %(self.id, subject)),
1935	urllib.quote(self.MAILTO_CC)
1936	)
1937
1938	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)
1939	return s
1940
1941	########## TRAC notify section ###########################################################
1942
1943	def notify(self, tkt, new=True, modtime=0):
1944	"""
1945	A wrapper for the TRAC notify function. So we can use templates
1946	"""
1947	if self.DRY_RUN:
1948	print 'DRY_RUN: self.notify(tkt, True) reporter = %s' %tkt['reporter']
1949	return
1950	try:
1951	# create false {abs_}href properties, to trick Notify()
1952	#
1953	if not (self.VERSION in [0.11, 0.12]):
1954	self.env.abs_href = Href(self.get_config('project', 'url'))
1955	self.env.href = Href(self.get_config('project', 'url'))
1956
1957	tn = TicketNotifyEmail(self.env)
1958
1959	if self.notify_template:
1960
1961	if self.VERSION == 0.11:
1962
1963	from trac.web.chrome import Chrome
1964
1965	if self.notify_template_update and not new:
1966	tn.template_name = self.notify_template_update
1967	else:
1968	tn.template_name = self.notify_template
1969
1970	tn.template = Chrome(tn.env).load_template(tn.template_name, method='text')
1971
1972	else:
1973
1974	tn.template_name = self.notify_template;
1975
1976	tn.notify(tkt, new, modtime)
1977
1978	except Exception, e:
1979	print 'TD: Failure sending notification on creation of ticket #%s: %s' %(self.id, e)
1980
1981
1982
1983	########## Parse Config File ###########################################################
1984
1985	def ReadConfig(file, name):
1986	"""
1987	Parse the config file
1988	"""
1989	if not os.path.isfile(file):
1990	print 'File %s does not exist' %file
1991	sys.exit(1)
1992
1993	config = trac_config.Configuration(file)
1994
1995	# Use given project name else use defaults
1996	#
1997	if name:
1998	sections = config.sections()
1999	if not name in sections:
2000	print "Not a valid project name: %s" %name
2001	print "Valid names: %s" %sections
2002	sys.exit(1)
2003
2004	project = dict()
2005	for option, value in config.options(name):
2006	project[option] = value
2007
2008	else:
2009	# use some trac internals to get the defaults
2010	#
2011	project = config.parser.defaults()
2012
2013	return project
2014
2015
2016	if __name__ == '__main__':
2017	# Default config file
2018	#
2019	configfile = '@email2trac_conf@'
2020	project = ''
2021	component = ''
2022	ticket_prefix = 'default'
2023	dry_run = None
2024	verbose = None
2025
2026	ENABLE_SYSLOG = 0
2027
2028	SHORT_OPT = 'chf:np:t:v'
2029	LONG_OPT = ['component=', 'dry-run', 'help', 'file=', 'project=', 'ticket_prefix=', 'verbose']
2030
2031	try:
2032	opts, args = getopt.getopt(sys.argv[1:], SHORT_OPT, LONG_OPT)
2033	except getopt.error,detail:
2034	print __doc__
2035	print detail
2036	sys.exit(1)
2037
2038	project_name = None
2039	for opt,value in opts:
2040	if opt in [ '-h', '--help']:
2041	print __doc__
2042	sys.exit(0)
2043	elif opt in ['-c', '--component']:
2044	component = value
2045	elif opt in ['-f', '--file']:
2046	configfile = value
2047	elif opt in ['-n', '--dry-run']:
2048	dry_run = True
2049	elif opt in ['-p', '--project']:
2050	project_name = value
2051	elif opt in ['-t', '--ticket_prefix']:
2052	ticket_prefix = value
2053	elif opt in ['-v', '--version']:
2054	verbose = True
2055
2056	settings = ReadConfig(configfile, project_name)
2057	if not settings.has_key('project'):
2058	print __doc__
2059	print 'No Trac project is defined in the email2trac config file.'
2060	sys.exit(1)
2061
2062	if component:
2063	settings['component'] = component
2064
2065	# The default prefix for ticket values in email2trac.conf
2066	#
2067	settings['ticket_prefix'] = ticket_prefix
2068	settings['dry_run'] = dry_run
2069	settings['verbose'] = verbose
2070
2071
2072	# Determine major trac version used to be in email2trac.conf
2073	# Quick hack for 0.12
2074	#
2075	version = '0.%s' %(trac_version.split('.')[1])
2076	if version.startswith('0.12'):
2077	version = '0.12'
2078
2079	if verbose:
2080	print "Found trac version: %s" %(version)
2081
2082	#debug HvB
2083	#print settings
2084
2085	try:
2086	if version == '0.9':
2087	from trac import attachment
2088	from trac.env import Environment
2089	from trac.ticket import Ticket
2090	from trac.web.href import Href
2091	from trac import util
2092	from trac.Notify import TicketNotifyEmail
2093	elif version == '0.10':
2094	from trac import attachment
2095	from trac.env import Environment
2096	from trac.ticket import Ticket
2097	from trac.web.href import Href
2098	from trac import util
2099	#
2100	# return util.text.to_unicode(str)
2101	#
2102	# see http://projects.edgewall.com/trac/changeset/2799
2103	from trac.ticket.notification import TicketNotifyEmail
2104	from trac import config as trac_config
2105	from trac.core import TracError
2106
2107	elif version == '0.11':
2108	from trac import attachment
2109	from trac.env import Environment
2110	from trac.ticket import Ticket
2111	from trac.web.href import Href
2112	from trac import config as trac_config
2113	from trac import util
2114	from trac.core import TracError
2115
2116	#
2117	# return util.text.to_unicode(str)
2118	#
2119	# see http://projects.edgewall.com/trac/changeset/2799
2120	from trac.ticket.notification import TicketNotifyEmail
2121
2122	elif version == '0.12':
2123	from trac import attachment
2124	from trac.env import Environment
2125	from trac.ticket import Ticket
2126	from trac.web.href import Href
2127	from trac import config as trac_config
2128	from trac import util
2129	from trac.core import TracError
2130
2131	#
2132	# return util.text.to_unicode(str)
2133	#
2134	# see http://projects.edgewall.com/trac/changeset/2799
2135	from trac.ticket.notification import TicketNotifyEmail
2136
2137
2138	else:
2139	print 'TRAC version %s is not supported' %version
2140	sys.exit(1)
2141
2142	if settings.has_key('enable_syslog'):
2143	if SYSLOG_AVAILABLE:
2144	ENABLE_SYSLOG = float(settings['enable_syslog'])
2145
2146
2147	# Must be set before environment is created
2148	#
2149	if settings.has_key('python_egg_cache'):
2150	python_egg_cache = str(settings['python_egg_cache'])
2151	os.environ['PYTHON_EGG_CACHE'] = python_egg_cache
2152
2153
2154	if int(settings['debug']) > 0:
2155	print 'Loading environment', settings['project']
2156
2157	env = Environment(settings['project'], create=0)
2158
2159	tktparser = TicketEmailParser(env, settings, float(version))
2160	tktparser.parse(sys.stdin)
2161
2162	# Catch all errors ans log to SYSLOG if we have enabled this
2163	# else stdout
2164	#
2165	except Exception, error:
2166	if ENABLE_SYSLOG:
2167	syslog.openlog('email2trac', syslog.LOG_NOWAIT)
2168
2169	etype, evalue, etb = sys.exc_info()
2170	for e in traceback.format_exception(etype, evalue, etb):
2171	syslog.syslog(e)
2172
2173	syslog.closelog()
2174	else:
2175	traceback.print_exc()
2176
2177	if m:
2178	tktparser.save_email_for_debug(m, True)
2179
2180
2181	sys.exit(1)
2182	# EOB

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format