Context Navigation

source: trunk/email2trac.py.in @ 407

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

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

Download in other formats:

Original Format