Context Navigation

source: trunk/email2trac.py.in @ 558

Last change on this file since 558 was 558, checked in by bas, 13 years ago
reporter ticket field can also be changed by a workflow, see #226
Property svn:executable set to ``* Property svn:keywords set to `Id`
File size: 80.4 KB

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

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

Download in other formats:

Original Format