Context Navigation

source: trunk/email2trac.py.in @ 217

Last change on this file since 217 was 217, checked in by bas, 16 years ago

email2trac.py.in:

See Changelog

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

File size: 30.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
	30	Changed By: Bas van der Vlies <basv@sara.nl>
	31	Date : 13 September 2005
	32	Descr. : Added config file and command line options, spam level
	33	detection, reply address and mailto option. Unicode support
	34
	35	Changed By: Walter de Jong <walter@sara.nl>
	36	Descr. : multipart-message code and trac attachments
	37
	38
	39	The scripts reads emails from stdin and inserts directly into a Trac database.
	40	MIME headers are mapped as follows:
	41
	42	* From: => Reporter
[152]	43	=> CC (Optional via reply_all option)
[22]	44	* Subject: => Summary
	45	* Body => Description
	46	* Component => Can be set to SPAM via spam_level option
	47
	48	How to use
	49	----------
	50	* Create an config file:
[74]	51	[DEFAULT] # REQUIRED
	52	project : /data/trac/test # REQUIRED
	53	debug : 1 # OPTIONAL, if set print some DEBUG info
	54	spam_level : 4 # OPTIONAL, if set check for SPAM mail
[152]	55	reply_all : 1 # OPTIONAL, if set then fill in ticket CC field
[87]	56	umask : 022 # OPTIONAL, if set then use this umask for creation of the attachments
[74]	57	mailto_link : 1 # OPTIONAL, if set then [mailto:<>] in description
[75]	58	mailto_cc : basv@sara.nl # OPTIONAL, use this address as CC in mailto line
[74]	59	ticket_update: 1 # OPTIONAL, if set then check if this is an update for a ticket
[172]	60	trac_version : 0.9 # OPTIONAL, default is 0.10
[22]	61
[148]	62	[jouvin] # OPTIONAL project declaration, if set both fields necessary
[22]	63	project : /data/trac/jouvin # use -p\|--project jouvin.
	64
	65	* default config file is : /etc/email2trac.conf
	66
	67	* Commandline opions:
[205]	68	-h,--help
	69	-f,--file <configuration file>
	70	-n,--dry-run
	71	-p, --project <project name>
	72	-t, --ticket_prefix <name>
[22]	73
	74	SVN Info:
	75	$Id: email2trac.py.in 217 2008-08-07 12:27:38Z bas $
	76	"""
	77	import os
	78	import sys
	79	import string
	80	import getopt
	81	import stat
	82	import time
	83	import email
[136]	84	import email.Iterators
	85	import email.Header
[22]	86	import re
	87	import urllib
	88	import unicodedata
	89	from stat import *
	90	import mimetypes
[96]	91	import traceback
[22]	92
[190]	93
	94	# Will fail where unavailable, e.g. Windows
	95	#
	96	try:
	97	import syslog
	98	SYSLOG_AVAILABLE = True
	99	except ImportError:
	100	SYSLOG_AVAILABLE = False
	101
[182]	102	from datetime import tzinfo, timedelta, datetime
[199]	103	from trac import config as trac_config
[91]	104
[96]	105	# Some global variables
	106	#
[189]	107	trac_default_version = '0.10'
[96]	108	m = None
[22]	109
[182]	110	# A UTC class needed for trac version 0.11, added by
	111	# tbaschak at ktc dot mb dot ca
	112	#
	113	class UTC(tzinfo):
	114	"""UTC"""
	115	ZERO = timedelta(0)
	116	HOUR = timedelta(hours=1)
	117
	118	def utcoffset(self, dt):
	119	return self.ZERO
	120
	121	def tzname(self, dt):
	122	return "UTC"
	123
	124	def dst(self, dt):
	125	return self.ZERO
	126
	127
[22]	128	class TicketEmailParser(object):
	129	env = None
	130	comment = '> '
	131
[206]	132	def __init__(self, env, parameters, version):
[22]	133	self.env = env
	134
	135	# Database connection
	136	#
	137	self.db = None
	138
[206]	139	# Save parameters
	140	#
	141	self.parameters = parameters
	142
[72]	143	# Some useful mail constants
	144	#
	145	self.author = None
	146	self.email_addr = None
[183]	147	self.email_from = None
[72]	148
[22]	149	self.VERSION = version
[206]	150	self.DRY_RUN = parameters['dry_run']
[204]	151
[172]	152	self.get_config = self.env.config.get
[22]	153
	154	if parameters.has_key('umask'):
	155	os.umask(int(parameters['umask'], 8))
	156
	157	if parameters.has_key('debug'):
	158	self.DEBUG = int(parameters['debug'])
	159	else:
	160	self.DEBUG = 0
	161
	162	if parameters.has_key('mailto_link'):
	163	self.MAILTO = int(parameters['mailto_link'])
[74]	164	if parameters.has_key('mailto_cc'):
	165	self.MAILTO_CC = parameters['mailto_cc']
	166	else:
	167	self.MAILTO_CC = ''
[22]	168	else:
	169	self.MAILTO = 0
	170
	171	if parameters.has_key('spam_level'):
	172	self.SPAM_LEVEL = int(parameters['spam_level'])
	173	else:
	174	self.SPAM_LEVEL = 0
	175
[207]	176	if parameters.has_key('spam_header'):
	177	self.SPAM_HEADER = parameters['spam_header']
	178	else:
	179	self.SPAM_HEADER = 'X-Spam-Score'
	180
[191]	181	if parameters.has_key('email_quote'):
	182	self.EMAIL_QUOTE = str(parameters['email_quote'])
	183	else:
	184	self.EMAIL_QUOTE = '> '
[22]	185
	186	if parameters.has_key('email_header'):
	187	self.EMAIL_HEADER = int(parameters['email_header'])
	188	else:
	189	self.EMAIL_HEADER = 0
	190
[42]	191	if parameters.has_key('alternate_notify_template'):
	192	self.notify_template = str(parameters['alternate_notify_template'])
	193	else:
	194	self.notify_template = None
[22]	195
[43]	196	if parameters.has_key('reply_all'):
	197	self.REPLY_ALL = int(parameters['reply_all'])
	198	else:
	199	self.REPLY_ALL = 0
[42]	200
[74]	201	if parameters.has_key('ticket_update'):
	202	self.TICKET_UPDATE = int(parameters['ticket_update'])
	203	else:
	204	self.TICKET_UPDATE = 0
[43]	205
[118]	206	if parameters.has_key('drop_spam'):
	207	self.DROP_SPAM = int(parameters['drop_spam'])
	208	else:
	209	self.DROP_SPAM = 0
[74]	210
[134]	211	if parameters.has_key('verbatim_format'):
	212	self.VERBATIM_FORMAT = int(parameters['verbatim_format'])
	213	else:
	214	self.VERBATIM_FORMAT = 1
[118]	215
[136]	216	if parameters.has_key('strip_signature'):
	217	self.STRIP_SIGNATURE = int(parameters['strip_signature'])
	218	else:
	219	self.STRIP_SIGNATURE = 0
[134]	220
[191]	221	if parameters.has_key('strip_quotes'):
	222	self.STRIP_QUOTES = int(parameters['strip_quotes'])
	223	else:
	224	self.STRIP_QUOTES = 0
	225
[148]	226	if parameters.has_key('use_textwrap'):
	227	self.USE_TEXTWRAP = int(parameters['use_textwrap'])
	228	else:
	229	self.USE_TEXTWRAP = 0
	230
[163]	231	if parameters.has_key('python_egg_cache'):
	232	self.python_egg_cache = str(parameters['python_egg_cache'])
	233	os.environ['PYTHON_EGG_CACHE'] = self.python_egg_cache
	234
[173]	235	# Use OS independend functions
	236	#
	237	self.TMPDIR = os.path.normcase('/tmp')
	238	if parameters.has_key('tmpdir'):
	239	self.TMPDIR = os.path.normcase(str(parameters['tmpdir']))
	240
[194]	241	if parameters.has_key('ignore_trac_user_settings'):
	242	self.IGNORE_TRAC_USER_SETTINGS = int(parameters['ignore_trac_user_settings'])
	243	else:
	244	self.IGNORE_TRAC_USER_SETTINGS = 0
[191]	245
[22]	246	def spam(self, message):
[191]	247	"""
	248	# X-Spam-Score: *** (3.255) BAYES_50,DNS_FROM_AHBL_RHSBL,HTML_
	249	# Note if Spam_level then '*' are included
	250	"""
[194]	251	spam = False
[207]	252	if message.has_key(self.SPAM_HEADER):
	253	spam_l = string.split(message[self.SPAM_HEADER])
[22]	254
[207]	255	try:
	256	number = spam_l[0].count('*')
	257	except IndexError, detail:
	258	number = 0
	259
[22]	260	if number >= self.SPAM_LEVEL:
[194]	261	spam = True
	262
[191]	263	# treat virus mails as spam
	264	#
	265	elif message.has_key('X-Virus-found'):
[194]	266	spam = True
	267
	268	# How to handle SPAM messages
	269	#
	270	if self.DROP_SPAM and spam:
	271	if self.DEBUG > 2 :
	272	print 'This message is a SPAM. Automatic ticket insertion refused (SPAM level > %d' % self.SPAM_LEVEL
	273
[204]	274	return 'drop'
[194]	275
	276	elif spam:
	277
[204]	278	return 'Spam'
[67]	279
[194]	280	else:
[22]	281
[204]	282	return False
[191]	283
[194]	284
[149]	285	def blacklisted_from(self):
[206]	286	"""
	287	This function wil check if the email address is in the black list
	288	"""
	289	try:
	290	black_list = self.parameters['black_list']
	291	except KeyError, detail:
	292	black_list = 'MAILER-DAEMON@'
	293
[208]	294	black_list = string.split(black_list)
	295	if not black_list.count('MAILER-DAEMON@'):
	296	black_list.append('MAILER-DAEMON@')
[206]	297
[208]	298	for entry in black_list:
[209]	299	entry = entry.strip()
[208]	300	FROM_RE = re.compile(entry, re.VERBOSE\|re.IGNORECASE)
	301	result = FROM_RE.search(self.email_addr)
	302	if result:
	303	return True
[149]	304
[208]	305	return False
	306
[139]	307	def email_to_unicode(self, message_str):
[22]	308	"""
	309	Email has 7 bit ASCII code, convert it to unicode with the charset
[79]	310	that is encoded in 7-bit ASCII code and encode it as utf-8 so Trac
[22]	311	understands it.
	312	"""
[139]	313	results = email.Header.decode_header(message_str)
[22]	314	str = None
	315	for text,format in results:
	316	if format:
	317	try:
	318	temp = unicode(text, format)
[139]	319	except UnicodeError, detail:
[22]	320	# This always works
	321	#
	322	temp = unicode(text, 'iso-8859-15')
[139]	323	except LookupError, detail:
	324	#text = 'ERROR: Could not find charset: %s, please install' %format
	325	#temp = unicode(text, 'iso-8859-15')
	326	temp = message_str
	327
[22]	328	else:
	329	temp = string.strip(text)
[92]	330	temp = unicode(text, 'iso-8859-15')
[22]	331
	332	if str:
[100]	333	str = '%s %s' %(str, temp)
[22]	334	else:
[100]	335	str = '%s' %temp
[22]	336
[139]	337	#str = str.encode('utf-8')
[22]	338	return str
	339
	340	def debug_attachments(self, message):
	341	n = 0
	342	for part in message.walk():
	343	if part.get_content_maintype() == 'multipart': # multipart/* is just a container
	344	print 'TD: multipart container'
	345	continue
	346
	347	n = n + 1
	348	print 'TD: part%d: Content-Type: %s' % (n, part.get_content_type())
	349	print 'TD: part%d: filename: %s' % (n, part.get_filename())
	350
	351	if part.is_multipart():
	352	print 'TD: this part is multipart'
	353	payload = part.get_payload(decode=1)
	354	print 'TD: payload:', payload
	355	else:
	356	print 'TD: this part is not multipart'
	357
[173]	358	file = 'part%d' %n
	359	part_file = os.path.join(self.TMPDIR, file)
	360	#part_file = '/var/tmp/part%d' % n
[22]	361	print 'TD: writing part%d (%s)' % (n,part_file)
	362	fx = open(part_file, 'wb')
	363	text = part.get_payload(decode=1)
	364	if not text:
	365	text = '(None)'
	366	fx.write(text)
	367	fx.close()
	368	try:
	369	os.chmod(part_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
	370	except OSError:
	371	pass
	372
	373	def email_header_txt(self, m):
[72]	374	"""
	375	Display To and CC addresses in description field
	376	"""
[22]	377	str = ''
[213]	378	#if m['To'] and len(m['To']) > 0 and m['To'] != 'hic@sara.nl':
	379	if m['To'] and len(m['To']) > 0:
	380	str = "'''To:''' %s\r\n" %(m['To'])
[22]	381	if m['Cc'] and len(m['Cc']) > 0:
[213]	382	str = "%s'''Cc:''' %s\r\n" % (str, m['Cc'])
[22]	383
[139]	384	return self.email_to_unicode(str)
[22]	385
[138]	386
[43]	387	def set_owner(self, ticket):
[45]	388	"""
	389	Select default owner for ticket component
	390	"""
[176]	391	#### return self.get_config('ticket', 'default_component')
[43]	392	cursor = self.db.cursor()
	393	sql = "SELECT owner FROM component WHERE name='%s'" % ticket['component']
	394	cursor.execute(sql)
[61]	395	try:
	396	ticket['owner'] = cursor.fetchone()[0]
	397	except TypeError, detail:
[176]	398	ticket['owner'] = None
[43]	399
[194]	400	def get_sender_info(self, message):
[45]	401	"""
[72]	402	Get the default author name and email address from the message
[45]	403	"""
[43]	404
[194]	405	self.email_from = self.email_to_unicode(message['from'])
	406	self.author, self.email_addr = email.Utils.parseaddr(self.email_from)
[142]	407
[194]	408	# Maybe for later user
	409	#self.email_from = self.email_to_unicode(self.email_addr)
	410
	411
	412	if self.IGNORE_TRAC_USER_SETTINGS:
	413	return
	414
	415	# Is this a registered user, use email address as search key:
	416	# result:
	417	# u : login name
	418	# n : Name that the user has set in the settings tab
	419	# e : email address that the user has set in the settings tab
[45]	420	#
[194]	421	users = [ (u,n,e) for (u, n, e) in self.env.get_known_users(self.db)
[72]	422	if e == self.email_addr ]
[43]	423
[45]	424	if len(users) == 1:
[194]	425	self.email_from = users[0][0]
[45]	426
[72]	427	def set_reply_fields(self, ticket, message):
	428	"""
	429	Set all the right fields for a new ticket
	430	"""
[183]	431	ticket['reporter'] = self.email_from
[72]	432
[45]	433	# Put all CC-addresses in ticket CC field
[43]	434	#
	435	if self.REPLY_ALL:
[45]	436	#tos = message.get_all('to', [])
[43]	437	ccs = message.get_all('cc', [])
	438
[45]	439	addrs = email.Utils.getaddresses(ccs)
[105]	440	if not addrs:
	441	return
[43]	442
	443	# Remove reporter email address if notification is
	444	# on
	445	#
	446	if self.notification:
	447	try:
[72]	448	addrs.remove((self.author, self.email_addr))
[43]	449	except ValueError, detail:
	450	pass
	451
[45]	452	for name,mail in addrs:
[105]	453	try:
[108]	454	mail_list = '%s, %s' %(mail_list, mail)
[105]	455	except:
	456	mail_list = mail
[43]	457
[105]	458	if mail_list:
[139]	459	ticket['cc'] = self.email_to_unicode(mail_list)
[96]	460
	461	def save_email_for_debug(self, message, tempfile=False):
	462	if tempfile:
	463	import tempfile
	464	msg_file = tempfile.mktemp('.email2trac')
	465	else:
[173]	466	#msg_file = '/var/tmp/msg.txt'
	467	msg_file = os.path.join(self.TMPDIR, 'msg.txt')
	468
[44]	469	print 'TD: saving email to %s' % msg_file
	470	fx = open(msg_file, 'wb')
	471	fx.write('%s' % message)
	472	fx.close()
	473	try:
	474	os.chmod(msg_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
	475	except OSError:
	476	pass
	477
[167]	478	def str_to_dict(self, str):
[164]	479	"""
	480	Transfrom a str of the form [<key>=<value>]+ to dict[<key>] = <value>
	481	"""
	482	# Skip the last ':' character
	483	#
	484	fields = string.split(str[:-1], ',')
	485
	486	result = dict()
	487	for field in fields:
	488	try:
	489	index, value = string.split(field,'=')
[169]	490
	491	# We can not change the description of a ticket via the subject
	492	# line. The description is the body of the email
	493	#
	494	if index.lower() in ['description']:
	495	continue
	496
[164]	497	if value:
[165]	498	result[index.lower()] = value
[169]	499
[164]	500	except ValueError:
	501	pass
	502
[165]	503	return result
[167]	504
[202]	505	def update_ticket_fields(self, ticket, user_dict, use_default=None):
	506	"""
	507	This will update the ticket fields. It will check if the
	508	given fields are known and if the right values are specified
	509	It will only update the ticket field value:
[169]	510	- If the field is known
[202]	511	- If the value supplied is valid for the ticket field.
	512	If not then there are two options:
	513	1) Skip the value (use_default=None)
	514	2) Set default value for field (use_default=1)
[169]	515	"""
	516
	517	# Build a system dictionary from the ticket fields
	518	# with field as index and option as value
	519	#
	520	sys_dict = dict()
	521	for field in ticket.fields:
[167]	522	try:
[169]	523	sys_dict[field['name']] = field['options']
	524
[167]	525	except KeyError:
[169]	526	sys_dict[field['name']] = None
[167]	527	pass
[169]	528
	529	# Check user supplied fields an compare them with the
	530	# system one's
	531	#
	532	for field,value in user_dict.items():
[202]	533	if self.DEBUG >= 10:
	534	print 'user_field\t %s = %s' %(field,value)
[169]	535
	536	if sys_dict.has_key(field):
	537
	538	# Check if value is an allowed system option, if TypeError then
	539	# every value is allowed
	540	#
	541	try:
	542	if value in sys_dict[field]:
	543	ticket[field] = value
[202]	544	else:
	545	# Must we set a default if value is not allowed
	546	#
	547	if use_default:
	548	value = self.get_config('ticket', 'default_%s' %(field) )
	549	ticket[field] = value
[169]	550
	551	except TypeError:
	552	ticket[field] = value
[202]	553
	554	if self.DEBUG >= 10:
	555	print 'ticket_field\t %s = %s' %(field, ticket[field])
[169]	556
[204]	557	def ticket_update(self, m, spam):
[78]	558	"""
[79]	559	If the current email is a reply to an existing ticket, this function
	560	will append the contents of this email to that ticket, instead of
	561	creating a new one.
[78]	562	"""
[202]	563
[71]	564	if not m['Subject']:
	565	return False
	566	else:
[139]	567	subject = self.email_to_unicode(m['Subject'])
[71]	568
[182]	569	# [hic] #1529: Re: LRZ
	570	# [hic] #1529?owner=bas,priority=medium: Re: LRZ
	571	#
[71]	572	TICKET_RE = re.compile(r"""
	573	(?P<ticketnr>[#][0-9]+:)
[194]	574	\|(?P<ticketnr_fields>[#][\d]+\?.*?:)
[71]	575	""", re.VERBOSE)
	576
	577	result = TICKET_RE.search(subject)
	578	if not result:
	579	return False
	580
[164]	581	# Must we update ticket fields
	582	#
[167]	583	update_tkt_fields = dict()
[165]	584	try:
[164]	585	nr, keywords = string.split(result.group('ticketnr_fields'), '?')
[167]	586	update_tkt_fields = self.str_to_dict(keywords)
[165]	587
	588	# Strip '#'
	589	#
	590	ticket_id = int(nr[1:])
	591
	592	except AttributeError:
	593	# Strip '#' and ':'
	594	#
[167]	595	nr = result.group('ticketnr')
[165]	596	ticket_id = int(nr[1:-1])
[164]	597
[71]	598
[194]	599	# When is the change committed
	600	#
[77]	601	#
[194]	602	if self.VERSION == 0.11:
	603	utc = UTC()
	604	when = datetime.now(utc)
	605	else:
	606	when = int(time.time())
[77]	607
[172]	608	try:
	609	tkt = Ticket(self.env, ticket_id, self.db)
	610	except util.TracError, detail:
	611	return False
[126]	612
[172]	613	# Must we update some ticket fields properties
	614	#
	615	if update_tkt_fields:
[169]	616	self.update_ticket_fields(tkt, update_tkt_fields)
[166]	617
[172]	618	body_text = self.get_body_text(m)
[210]	619
[215]	620	# reopen the ticket if is was closed
	621	#
[214]	622	if tkt['status'] in ['closed']:
	623	tkt['status'] = 'reopened'
[215]	624	tkt['resolution'] = ''
[214]	625
[177]	626	if self.EMAIL_HEADER:
	627	head = self.email_header_txt(m)
[213]	628	body_text = u"%s\r\n%s" %(head, body_text)
[76]	629
[172]	630	tkt.save_changes(self.author, body_text, when)
	631	tkt['id'] = ticket_id
	632
[129]	633	if self.VERSION == 0.9:
[152]	634	str = self.attachments(m, tkt, True)
[129]	635	else:
[152]	636	str = self.attachments(m, tkt)
[76]	637
[204]	638	if self.notification and not spam:
[77]	639	self.notify(tkt, False, when)
[72]	640
[71]	641	return True
	642
[202]	643	def set_ticket_fields(self, ticket):
[77]	644	"""
[202]	645	set the ticket fields to value specified
	646	- /etc/email2trac.conf with <prefix>_<field>
	647	- trac default values, trac.ini
	648	"""
	649	user_dict = dict()
	650
	651	for field in ticket.fields:
	652
	653	name = field['name']
	654
[215]	655	# skip some fields like resolution
	656	#
	657	if name in [ 'resolution' ]:
	658	continue
	659
[202]	660	# default trac value
	661	#
	662	value = self.get_config('ticket', 'default_%s' %(name) )
	663	if self.DEBUG > 10:
	664	print 'trac.ini name %s = %s' %(name, value)
	665
[206]	666	prefix = self.parameters['ticket_prefix']
[202]	667	try:
[206]	668	value = self.parameters['%s_%s' %(prefix, name)]
[202]	669	if self.DEBUG > 10:
	670	print 'email2trac.conf %s = %s ' %(name, value)
	671
	672	except KeyError, detail:
	673	pass
	674
	675	if self.DEBUG:
	676	print 'user_dict[%s] = %s' %(name, value)
	677
	678	user_dict[name] = value
	679
	680	self.update_ticket_fields(ticket, user_dict, use_default=1)
	681
	682	# Set status ticket
	683	#`
	684	ticket['status'] = 'new'
	685
	686
	687
[204]	688	def new_ticket(self, msg, spam):
[202]	689	"""
[77]	690	Create a new ticket
	691	"""
[41]	692	tkt = Ticket(self.env)
[22]	693
[202]	694	self.set_ticket_fields(tkt)
	695
[22]	696	# Some defaults
	697	#
[202]	698	#tkt['status'] = 'new'
	699	#tkt['milestone'] = self.get_config('ticket', 'default_milestone')
	700	#tkt['priority'] = self.get_config('ticket', 'default_priority')
	701	#tkt['severity'] = self.get_config('ticket', 'default_severity')
	702	#tkt['version'] = self.get_config('ticket', 'default_version')
	703	#tkt['type'] = self.get_config('ticket', 'default_type')
[22]	704
[202]	705	# Old style setting for component, will be removed
	706	#
[204]	707	if spam:
	708	tkt['component'] = 'Spam'
	709
[206]	710	elif self.parameters.has_key('component'):
	711	tkt['component'] = self.parameters['component']
[201]	712
[22]	713	if not msg['Subject']:
[151]	714	tkt['summary'] = u'(No subject)'
[22]	715	else:
[139]	716	tkt['summary'] = self.email_to_unicode(msg['Subject'])
[22]	717
	718
[72]	719	self.set_reply_fields(tkt, msg)
[22]	720
[45]	721	# produce e-mail like header
	722	#
[22]	723	head = ''
	724	if self.EMAIL_HEADER > 0:
	725	head = self.email_header_txt(msg)
[92]	726
[72]	727	body_text = self.get_body_text(msg)
[45]	728
[213]	729	tkt['description'] = '%s\r\n%s' \
[142]	730	%(head, body_text)
[90]	731
[182]	732	#when = int(time.time())
[192]	733	#
[182]	734	utc = UTC()
	735	when = datetime.now(utc)
[45]	736
[204]	737	if self.DRY_RUN:
[201]	738	ticket_id = 'DRY_RUN'
	739	else:
	740	ticket_id = tkt.insert()
[187]	741
[172]	742	tkt['id'] = ticket_id
	743
[90]	744	changed = False
	745	comment = ''
[77]	746
[90]	747	# Rewrite the description if we have mailto enabled
[45]	748	#
[72]	749	if self.MAILTO:
[100]	750	changed = True
[142]	751	comment = u'\nadded mailto line\n'
[210]	752	#mailto = self.html_mailto_link(tkt['summary'], ticket_id, body_text)
	753	mailto = self.html_mailto_link( m['Subject'], ticket_id, body_text)
[213]	754	tkt['description'] = u'%s\r\n%s%s\r\n' \
[142]	755	%(head, mailto, body_text)
[45]	756
[152]	757	str = self.attachments(msg, tkt)
	758	if str:
[100]	759	changed = True
[152]	760	comment = '%s\n%s\n' %(comment, str)
[77]	761
[90]	762	if changed:
[204]	763	if self.DRY_RUN:
[201]	764	print 'DRY_RUN: tkt.save_changes(self.author, comment)'
	765	else:
	766	tkt.save_changes(self.author, comment)
	767	#print tkt.get_changelog(self.db, when)
[90]	768
[45]	769	if self.notification:
[204]	770	if self.DRY_RUN:
[202]	771	print 'DRY_RUN: self.notify(tkt, True)'
	772	else:
[204]	773	if not spam:
	774	self.notify(tkt, True)
[202]	775	#self.notify(tkt, False)
[45]	776
[77]	777	def parse(self, fp):
[96]	778	global m
	779
[77]	780	m = email.message_from_file(fp)
	781	if not m:
	782	return
	783
	784	if self.DEBUG > 1: # save the entire e-mail message text
	785	self.save_email_for_debug(m)
	786	self.debug_attachments(m)
	787
	788	self.db = self.env.get_db_cnx()
[194]	789	self.get_sender_info(m)
[152]	790
[149]	791	if self.blacklisted_from():
	792	if self.DEBUG > 1 :
	793	print 'Message rejected : From: in blacklist'
	794	return False
[77]	795
[204]	796	# If drop the message
[194]	797	#
[204]	798	if self.spam(m) == 'drop':
[194]	799	return False
	800
[204]	801	elif self.spam(m) == 'spam':
	802	spam_msg = True
[194]	803
[204]	804	else:
	805	spam_msg = False
	806
[77]	807	if self.get_config('notification', 'smtp_enabled') in ['true']:
	808	self.notification = 1
	809	else:
	810	self.notification = 0
	811
	812	# Must we update existing tickets
	813	#
	814	if self.TICKET_UPDATE > 0:
[204]	815	if self.ticket_update(m, spam_msg):
[77]	816	return True
	817
[204]	818	self.new_ticket(m, spam_msg)
[77]	819
[136]	820	def strip_signature(self, text):
	821	"""
	822	Strip signature from message, inspired by Mailman software
	823	"""
	824	body = []
	825	for line in text.splitlines():
	826	if line == '-- ':
	827	break
	828	body.append(line)
	829
	830	return ('\n'.join(body))
	831
[191]	832	def strip_quotes(self, text):
[193]	833	"""
	834	Strip quotes from message by Nicolas Mendoza
	835	"""
	836	body = []
	837	for line in text.splitlines():
	838	if line.startswith(self.EMAIL_QUOTE):
	839	continue
	840	body.append(line)
[151]	841
[193]	842	return ('\n'.join(body))
[191]	843
[154]	844	def wrap_text(self, text, replace_whitespace = False):
[151]	845	"""
[191]	846	Will break a lines longer then given length into several small
	847	lines of size given length
[151]	848	"""
	849	import textwrap
[154]	850
[151]	851	LINESEPARATOR = '\n'
[153]	852	reformat = ''
[151]	853
[154]	854	for s in text.split(LINESEPARATOR):
	855	tmp = textwrap.fill(s,self.USE_TEXTWRAP)
	856	if tmp:
	857	reformat = '%s\n%s' %(reformat,tmp)
	858	else:
	859	reformat = '%s\n' %reformat
[153]	860
	861	return reformat
	862
[154]	863	# Python2.4 and higher
	864	#
	865	#return LINESEPARATOR.join(textwrap.fill(s,width) for s in str.split(LINESEPARATOR))
	866	#
	867
	868
[72]	869	def get_body_text(self, msg):
[45]	870	"""
[79]	871	put the message text in the ticket description or in the changes field.
[45]	872	message text can be plain text or html or something else
	873	"""
[22]	874	has_description = 0
[100]	875	encoding = True
[109]	876	ubody_text = u'No plain text message'
[22]	877	for part in msg.walk():
[45]	878
	879	# 'multipart/*' is a container for multipart messages
	880	#
	881	if part.get_content_maintype() == 'multipart':
[22]	882	continue
	883
	884	if part.get_content_type() == 'text/plain':
[45]	885	# Try to decode, if fails then do not decode
	886	#
[90]	887	body_text = part.get_payload(decode=1)
[45]	888	if not body_text:
[90]	889	body_text = part.get_payload(decode=0)
[154]	890
[136]	891	if self.STRIP_SIGNATURE:
	892	body_text = self.strip_signature(body_text)
[22]	893
[191]	894	if self.STRIP_QUOTES:
	895	body_text = self.strip_quotes(body_text)
	896
[148]	897	if self.USE_TEXTWRAP:
[151]	898	body_text = self.wrap_text(body_text)
[148]	899
[45]	900	# Get contents charset (iso-8859-15 if not defined in mail headers)
	901	#
[100]	902	charset = part.get_content_charset()
[102]	903	if not charset:
	904	charset = 'iso-8859-15'
	905
[89]	906	try:
[96]	907	ubody_text = unicode(body_text, charset)
[100]	908
	909	except UnicodeError, detail:
[96]	910	ubody_text = unicode(body_text, 'iso-8859-15')
[89]	911
[100]	912	except LookupError, detail:
[139]	913	ubody_text = 'ERROR: Could not find charset: %s, please install' %(charset)
[100]	914
[22]	915	elif part.get_content_type() == 'text/html':
[109]	916	ubody_text = '(see attachment for HTML mail message)'
[22]	917
	918	else:
[109]	919	ubody_text = '(see attachment for message)'
[22]	920
	921	has_description = 1
	922	break # we have the description, so break
	923
	924	if not has_description:
[109]	925	ubody_text = '(see attachment for message)'
[22]	926
[100]	927	# A patch so that the web-interface will not update the description
	928	# field of a ticket
	929	#
	930	ubody_text = ('\r\n'.join(ubody_text.splitlines()))
[22]	931
[100]	932	# If we can unicode it try to encode it for trac
	933	# else we a lot of garbage
	934	#
[142]	935	#if encoding:
	936	# ubody_text = ubody_text.encode('utf-8')
[100]	937
[134]	938	if self.VERBATIM_FORMAT:
	939	ubody_text = '{{{\r\n%s\r\n}}}' %ubody_text
	940	else:
	941	ubody_text = '%s' %ubody_text
	942
[100]	943	return ubody_text
	944
[77]	945	def notify(self, tkt , new=True, modtime=0):
[79]	946	"""
	947	A wrapper for the TRAC notify function. So we can use templates
	948	"""
[41]	949	try:
	950	# create false {abs_}href properties, to trick Notify()
	951	#
[193]	952	if not self.VERSION == 0.11:
[192]	953	self.env.abs_href = Href(self.get_config('project', 'url'))
	954	self.env.href = Href(self.get_config('project', 'url'))
[22]	955
[41]	956	tn = TicketNotifyEmail(self.env)
[213]	957
[42]	958	if self.notify_template:
	959	tn.template_name = self.notify_template;
	960
[77]	961	tn.notify(tkt, new, modtime)
[41]	962
	963	except Exception, e:
[79]	964	print 'TD: Failure sending notification on creation of ticket #%s: %s' %(tkt['id'], e)
[41]	965
[72]	966	def html_mailto_link(self, subject, id, body):
	967	if not self.author:
[143]	968	author = self.email_addr
[22]	969	else:
[142]	970	author = self.author
[22]	971
	972	# Must find a fix
	973	#
	974	#arr = string.split(body, '\n')
	975	#arr = map(self.mail_line, arr)
	976	#body = string.join(arr, '\n')
	977	#body = '%s wrote:\n%s' %(author, body)
	978
	979	# Temporary fix
[142]	980	#
[74]	981	str = 'mailto:%s?Subject=%s&Cc=%s' %(
	982	urllib.quote(self.email_addr),
	983	urllib.quote('Re: #%s: %s' %(id, subject)),
	984	urllib.quote(self.MAILTO_CC)
	985	)
	986
[213]	987	str = '\r\n{{{\r\n#!html\r\n<a\r\n href="%s">Reply to: %s\r\n</a>\r\n}}}\r\n' %(str, author)
[22]	988	return str
	989
[129]	990	def attachments(self, message, ticket, update=False):
[79]	991	'''
	992	save any attachments as files in the ticket's directory
	993	'''
[22]	994	count = 0
[77]	995	first = 0
	996	number = 0
[152]	997
	998	# Get Maxium attachment size
	999	#
	1000	max_size = int(self.get_config('attachment', 'max_size'))
[153]	1001	status = ''
[152]	1002
[22]	1003	for part in message.walk():
	1004	if part.get_content_maintype() == 'multipart': # multipart/* is just a container
	1005	continue
	1006
	1007	if not first: # first content is the message
	1008	first = 1
	1009	if part.get_content_type() == 'text/plain': # if first is text, is was already put in the description
	1010	continue
	1011
	1012	filename = part.get_filename()
	1013	if not filename:
[77]	1014	number = number + 1
	1015	filename = 'part%04d' % number
[22]	1016
[72]	1017	ext = mimetypes.guess_extension(part.get_content_type())
[22]	1018	if not ext:
	1019	ext = '.bin'
	1020
	1021	filename = '%s%s' % (filename, ext)
	1022	else:
[139]	1023	filename = self.email_to_unicode(filename)
[22]	1024
[48]	1025	# From the trac code
	1026	#
	1027	filename = filename.replace('\\', '/').replace(':', '/')
	1028	filename = os.path.basename(filename)
[22]	1029
[48]	1030	# We try to normalize the filename to utf-8 NFC if we can.
	1031	# Files uploaded from OS X might be in NFD.
[92]	1032	# Check python version and then try it
[48]	1033	#
	1034	if sys.version_info[0] > 2 or (sys.version_info[0] == 2 and sys.version_info[1] >= 3):
[92]	1035	try:
	1036	filename = unicodedata.normalize('NFC', unicode(filename, 'utf-8')).encode('utf-8')
	1037	except TypeError:
	1038	pass
[48]	1039
[22]	1040	url_filename = urllib.quote(filename)
[172]	1041	#
	1042	# Must be tuneables HvB
	1043	#
[173]	1044	path, fd = util.create_unique_file(os.path.join(self.TMPDIR, url_filename))
[22]	1045	text = part.get_payload(decode=1)
	1046	if not text:
	1047	text = '(None)'
[48]	1048	fd.write(text)
	1049	fd.close()
[22]	1050
[153]	1051	# get the file_size
[22]	1052	#
[48]	1053	stats = os.lstat(path)
[153]	1054	file_size = stats[stat.ST_SIZE]
[22]	1055
[152]	1056	# Check if the attachment size is allowed
	1057	#
[153]	1058	if (max_size != -1) and (file_size > max_size):
	1059	status = '%s\nFile %s is larger then allowed attachment size (%d > %d)\n\n' \
	1060	%(status, filename, file_size, max_size)
[152]	1061
	1062	os.unlink(path)
	1063	continue
	1064	else:
	1065	count = count + 1
	1066
[172]	1067	# Insert the attachment
[73]	1068	#
[172]	1069	fd = open(path)
	1070	att = attachment.Attachment(self.env, 'ticket', ticket['id'])
[73]	1071
[172]	1072	# This will break the ticket_update system, the body_text is vaporized
	1073	# ;-(
	1074	#
	1075	if not update:
	1076	att.author = self.author
	1077	att.description = self.email_to_unicode('Added by email2trac')
[73]	1078
[172]	1079	att.insert(url_filename, fd, file_size)
	1080	#except util.TracError, detail:
	1081	# print detail
[73]	1082
[103]	1083	# Remove the created temporary filename
	1084	#
[172]	1085	fd.close()
[103]	1086	os.unlink(path)
	1087
[77]	1088	# Return how many attachments
	1089	#
[153]	1090	status = 'This message has %d attachment(s)\n%s' %(count, status)
	1091	return status
[22]	1092
[77]	1093
[22]	1094	def mkdir_p(dir, mode):
	1095	'''do a mkdir -p'''
	1096
	1097	arr = string.split(dir, '/')
	1098	path = ''
	1099	for part in arr:
	1100	path = '%s/%s' % (path, part)
	1101	try:
	1102	stats = os.stat(path)
	1103	except OSError:
	1104	os.mkdir(path, mode)
	1105
	1106	def ReadConfig(file, name):
	1107	"""
	1108	Parse the config file
	1109	"""
	1110	if not os.path.isfile(file):
[79]	1111	print 'File %s does not exist' %file
[22]	1112	sys.exit(1)
	1113
[199]	1114	config = trac_config.Configuration(file)
[22]	1115
	1116	# Use given project name else use defaults
	1117	#
	1118	if name:
[199]	1119	sections = config.sections()
	1120	if not name in sections:
[79]	1121	print "Not a valid project name: %s" %name
[199]	1122	print "Valid names: %s" %sections
[22]	1123	sys.exit(1)
	1124
	1125	project = dict()
[199]	1126	for option, value in config.options(name):
	1127	project[option] = value
[22]	1128
	1129	else:
[217]	1130	# use some trac internales to get the defaults
	1131	#
	1132	project = config.parser.defaults()
[22]	1133
	1134	return project
	1135
[87]	1136
[22]	1137	if __name__ == '__main__':
	1138	# Default config file
	1139	#
[24]	1140	configfile = '@email2trac_conf@'
[22]	1141	project = ''
	1142	component = ''
[202]	1143	ticket_prefix = 'default'
[204]	1144	dry_run = None
[202]	1145
[87]	1146	ENABLE_SYSLOG = 0
[201]	1147
[204]	1148
[202]	1149	SHORT_OPT = 'chf:np:t:'
	1150	LONG_OPT = ['component=', 'dry-run', 'help', 'file=', 'project=', 'ticket_prefix=']
[201]	1151
[22]	1152	try:
[201]	1153	opts, args = getopt.getopt(sys.argv[1:], SHORT_OPT, LONG_OPT)
[22]	1154	except getopt.error,detail:
	1155	print __doc__
	1156	print detail
	1157	sys.exit(1)
[87]	1158
[22]	1159	project_name = None
	1160	for opt,value in opts:
	1161	if opt in [ '-h', '--help']:
	1162	print __doc__
	1163	sys.exit(0)
	1164	elif opt in ['-c', '--component']:
	1165	component = value
	1166	elif opt in ['-f', '--file']:
	1167	configfile = value
[201]	1168	elif opt in ['-n', '--dry-run']:
[204]	1169	dry_run = True
[22]	1170	elif opt in ['-p', '--project']:
	1171	project_name = value
[202]	1172	elif opt in ['-t', '--ticket_prefix']:
	1173	ticket_prefix = value
[87]	1174
[22]	1175	settings = ReadConfig(configfile, project_name)
	1176	if not settings.has_key('project'):
	1177	print __doc__
[79]	1178	print 'No Trac project is defined in the email2trac config file.'
[22]	1179	sys.exit(1)
[87]	1180
[22]	1181	if component:
	1182	settings['component'] = component
[202]	1183
	1184	# The default prefix for ticket values in email2trac.conf
	1185	#
	1186	settings['ticket_prefix'] = ticket_prefix
[206]	1187	settings['dry_run'] = dry_run
[87]	1188
[22]	1189	if settings.has_key('trac_version'):
[189]	1190	version = settings['trac_version']
[22]	1191	else:
	1192	version = trac_default_version
	1193
[189]	1194
[22]	1195	#debug HvB
	1196	#print settings
[189]	1197
[87]	1198	try:
[189]	1199	if version == '0.9':
[87]	1200	from trac import attachment
	1201	from trac.env import Environment
	1202	from trac.ticket import Ticket
	1203	from trac.web.href import Href
	1204	from trac import util
	1205	from trac.Notify import TicketNotifyEmail
[189]	1206	elif version == '0.10':
[87]	1207	from trac import attachment
	1208	from trac.env import Environment
	1209	from trac.ticket import Ticket
	1210	from trac.web.href import Href
	1211	from trac import util
[139]	1212	#
	1213	# return util.text.to_unicode(str)
	1214	#
[87]	1215	# see http://projects.edgewall.com/trac/changeset/2799
	1216	from trac.ticket.notification import TicketNotifyEmail
[199]	1217	from trac import config as trac_config
[189]	1218	elif version == '0.11':
[182]	1219	from trac import attachment
	1220	from trac.env import Environment
	1221	from trac.ticket import Ticket
	1222	from trac.web.href import Href
[199]	1223	from trac import config as trac_config
[182]	1224	from trac import util
	1225	#
	1226	# return util.text.to_unicode(str)
	1227	#
	1228	# see http://projects.edgewall.com/trac/changeset/2799
	1229	from trac.ticket.notification import TicketNotifyEmail
[189]	1230	else:
	1231	print 'TRAC version %s is not supported' %version
	1232	sys.exit(1)
	1233
	1234	if settings.has_key('enable_syslog'):
[190]	1235	if SYSLOG_AVAILABLE:
	1236	ENABLE_SYSLOG = float(settings['enable_syslog'])
[182]	1237
[87]	1238	env = Environment(settings['project'], create=0)
[206]	1239	tktparser = TicketEmailParser(env, settings, float(version))
[87]	1240	tktparser.parse(sys.stdin)
[22]	1241
[87]	1242	# Catch all errors ans log to SYSLOG if we have enabled this
	1243	# else stdout
	1244	#
	1245	except Exception, error:
	1246	if ENABLE_SYSLOG:
	1247	syslog.openlog('email2trac', syslog.LOG_NOWAIT)
[187]	1248
[87]	1249	etype, evalue, etb = sys.exc_info()
	1250	for e in traceback.format_exception(etype, evalue, etb):
	1251	syslog.syslog(e)
[187]	1252
[87]	1253	syslog.closelog()
	1254	else:
	1255	traceback.print_exc()
[22]	1256
[97]	1257	if m:
[98]	1258	tktparser.save_email_for_debug(m, True)
[97]	1259
[22]	1260	# EOB

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

Download in other formats:

Original Format