Context Navigation

source: trunk/email2trac.py.in @ 379

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

email2trac.py.in:

added print_unicode function. So we can delete some code lines,

Property svn:executable set to *
Property svn:keywords set to Id

File size: 54.4 KB

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

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

Download in other formats:

Original Format