Context Navigation

source: trunk/email2trac.py.in @ 578

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

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

Download in other formats:

Original Format