Context Navigation

source: trunk/email2trac.py.in @ 321

Last change on this file since 321 was 321, checked in by bas, 14 years ago
Some variable renaming
Property svn:executable set to ``* Property svn:keywords set to `Id`
File size: 43.0 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
[297]	44	trac_version : 0.10 # OPTIONAL, default is 0.11
[22]	45
[282]	46	[jouvin] # OPTIONAL project declaration, if set both fields necessary
	47	project : /data/trac/jouvin # use -p\|--project jouvin.
[22]	48
	49	* default config file is : /etc/email2trac.conf
	50
	51	* Commandline opions:
[205]	52	-h,--help
	53	-f,--file <configuration file>
	54	-n,--dry-run
	55	-p, --project <project name>
	56	-t, --ticket_prefix <name>
[22]	57
	58	SVN Info:
	59	$Id: email2trac.py.in 321 2010-02-22 14:47:17Z bas $
	60	"""
	61	import os
	62	import sys
	63	import string
	64	import getopt
	65	import stat
	66	import time
	67	import email
[136]	68	import email.Iterators
	69	import email.Header
[22]	70	import re
	71	import urllib
	72	import unicodedata
	73	from stat import *
	74	import mimetypes
[96]	75	import traceback
[22]	76
[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 = '> '
	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
[118]	200	if parameters.has_key('drop_spam'):
	201	self.DROP_SPAM = int(parameters['drop_spam'])
	202	else:
	203	self.DROP_SPAM = 0
[74]	204
[134]	205	if parameters.has_key('verbatim_format'):
	206	self.VERBATIM_FORMAT = int(parameters['verbatim_format'])
	207	else:
	208	self.VERBATIM_FORMAT = 1
[118]	209
[231]	210	if parameters.has_key('reflow'):
[256]	211	self.REFLOW = int(parameters['reflow'])
[231]	212	else:
	213	self.REFLOW = 1
	214
[278]	215	if parameters.has_key('drop_alternative_html_version'):
	216	self.DROP_ALTERNATIVE_HTML_VERSION = int(parameters['drop_alternative_html_version'])
	217	else:
	218	self.DROP_ALTERNATIVE_HTML_VERSION = 0
	219
[136]	220	if parameters.has_key('strip_signature'):
	221	self.STRIP_SIGNATURE = int(parameters['strip_signature'])
	222	else:
	223	self.STRIP_SIGNATURE = 0
[134]	224
[191]	225	if parameters.has_key('strip_quotes'):
	226	self.STRIP_QUOTES = int(parameters['strip_quotes'])
	227	else:
	228	self.STRIP_QUOTES = 0
	229
[309]	230	self.properties = dict()
	231	if parameters.has_key('inline_properties'):
	232	self.INLINE_PROPERTIES = int(parameters['inline_properties'])
	233	else:
	234	self.INLINE_PROPERTIES = 0
	235
[148]	236	if parameters.has_key('use_textwrap'):
	237	self.USE_TEXTWRAP = int(parameters['use_textwrap'])
	238	else:
	239	self.USE_TEXTWRAP = 0
	240
[238]	241	if parameters.has_key('binhex'):
[294]	242	self.STRIP_CONTENT_TYPES.append('application/mac-binhex40')
[238]	243
	244	if parameters.has_key('applesingle'):
[294]	245	self.STRIP_CONTENT_TYPES.append('application/applefile')
[238]	246
	247	if parameters.has_key('appledouble'):
[294]	248	self.STRIP_CONTENT_TYPES.append('application/applefile')
[238]	249
[294]	250	if parameters.has_key('strip_content_types'):
	251	items = parameters['strip_content_types'].split(',')
	252	for item in items:
	253	self.STRIP_CONTENT_TYPES.append(item.strip())
	254
[257]	255	self.WORKFLOW = None
	256	if parameters.has_key('workflow'):
	257	self.WORKFLOW = parameters['workflow']
	258
[173]	259	# Use OS independend functions
	260	#
	261	self.TMPDIR = os.path.normcase('/tmp')
	262	if parameters.has_key('tmpdir'):
	263	self.TMPDIR = os.path.normcase(str(parameters['tmpdir']))
	264
[194]	265	if parameters.has_key('ignore_trac_user_settings'):
	266	self.IGNORE_TRAC_USER_SETTINGS = int(parameters['ignore_trac_user_settings'])
	267	else:
	268	self.IGNORE_TRAC_USER_SETTINGS = 0
[191]	269
[320]	270	if parameters.has_key('email_triggers_workflow'):
	271	self.EMAIL_TRIGGERS_WORKFLOW = int(parameters['email_triggers_workflow'])
	272	else:
	273	self.EMAIL_TRIGGERS_WORKFLOW = 1
	274
[297]	275	if parameters.has_key('subject_field_separator'):
	276	self.SUBJECT_FIELD_SEPARATOR = parameters['subject_field_separator'].strip()
	277	else:
	278	self.SUBJECT_FIELD_SEPARATOR = '&'
	279
[305]	280	self.trac_smtp_from = self.get_config('notification', 'smtp_from')
	281
[22]	282	def spam(self, message):
[191]	283	"""
	284	# X-Spam-Score: *** (3.255) BAYES_50,DNS_FROM_AHBL_RHSBL,HTML_
	285	# Note if Spam_level then '*' are included
	286	"""
[194]	287	spam = False
[207]	288	if message.has_key(self.SPAM_HEADER):
	289	spam_l = string.split(message[self.SPAM_HEADER])
[22]	290
[207]	291	try:
	292	number = spam_l[0].count('*')
	293	except IndexError, detail:
	294	number = 0
	295
[22]	296	if number >= self.SPAM_LEVEL:
[194]	297	spam = True
	298
[191]	299	# treat virus mails as spam
	300	#
	301	elif message.has_key('X-Virus-found'):
[194]	302	spam = True
	303
	304	# How to handle SPAM messages
	305	#
	306	if self.DROP_SPAM and spam:
	307	if self.DEBUG > 2 :
	308	print 'This message is a SPAM. Automatic ticket insertion refused (SPAM level > %d' % self.SPAM_LEVEL
	309
[204]	310	return 'drop'
[194]	311
	312	elif spam:
	313
[204]	314	return 'Spam'
[67]	315
[194]	316	else:
[22]	317
[204]	318	return False
[191]	319
[221]	320	def email_header_acl(self, keyword, header_field, default):
[206]	321	"""
[221]	322	This function wil check if the email address is allowed or denied
	323	to send mail to the ticket list
	324	"""
[206]	325	try:
[221]	326	mail_addresses = self.parameters[keyword]
	327
	328	# Check if we have an empty string
	329	#
	330	if not mail_addresses:
	331	return default
	332
[206]	333	except KeyError, detail:
[221]	334	if self.DEBUG > 2 :
[250]	335	print 'TD: %s not defined, all messages are allowed.' %(keyword)
[206]	336
[221]	337	return default
[206]	338
[221]	339	mail_addresses = string.split(mail_addresses, ',')
	340
	341	for entry in mail_addresses:
[209]	342	entry = entry.strip()
[221]	343	TO_RE = re.compile(entry, re.VERBOSE\|re.IGNORECASE)
	344	result = TO_RE.search(header_field)
[208]	345	if result:
	346	return True
[149]	347
[208]	348	return False
	349
[139]	350	def email_to_unicode(self, message_str):
[22]	351	"""
	352	Email has 7 bit ASCII code, convert it to unicode with the charset
[79]	353	that is encoded in 7-bit ASCII code and encode it as utf-8 so Trac
[22]	354	understands it.
	355	"""
[317]	356	if self.VERBOSE:
	357	print "VB: email_to_unicode"
	358
[139]	359	results = email.Header.decode_header(message_str)
[318]	360
[288]	361	s = None
[22]	362	for text,format in results:
	363	if format:
	364	try:
	365	temp = unicode(text, format)
[139]	366	except UnicodeError, detail:
[22]	367	# This always works
	368	#
	369	temp = unicode(text, 'iso-8859-15')
[139]	370	except LookupError, detail:
	371	#text = 'ERROR: Could not find charset: %s, please install' %format
	372	#temp = unicode(text, 'iso-8859-15')
	373	temp = message_str
	374
[22]	375	else:
	376	temp = string.strip(text)
[92]	377	temp = unicode(text, 'iso-8859-15')
[22]	378
[288]	379	if s:
	380	s = '%s %s' %(s, temp)
[22]	381	else:
[288]	382	s = '%s' %temp
[22]	383
[288]	384	#s = s.encode('utf-8')
	385	return s
[22]	386
[236]	387
[22]	388	def email_header_txt(self, m):
[72]	389	"""
	390	Display To and CC addresses in description field
	391	"""
[288]	392	s = ''
[213]	393	#if m['To'] and len(m['To']) > 0 and m['To'] != 'hic@sara.nl':
	394	if m['To'] and len(m['To']) > 0:
[288]	395	s = "'''To:''' %s\r\n" %(m['To'])
[22]	396	if m['Cc'] and len(m['Cc']) > 0:
[288]	397	s = "%s'''Cc:''' %s\r\n" % (s, m['Cc'])
[22]	398
[288]	399	return self.email_to_unicode(s)
[22]	400
[138]	401
[194]	402	def get_sender_info(self, message):
[45]	403	"""
[72]	404	Get the default author name and email address from the message
[226]	405	"""
[43]	406
[226]	407	self.email_to = self.email_to_unicode(message['to'])
	408	self.to_name, self.to_email_addr = email.Utils.parseaddr (self.email_to)
	409
[194]	410	self.email_from = self.email_to_unicode(message['from'])
[287]	411	self.email_name, self.email_addr = email.Utils.parseaddr(self.email_from)
[142]	412
[304]	413	## Trac can not handle author's name that contains spaces
	414	# and forbid the ticket email address as author field
[194]	415
[305]	416	if self.email_addr == self.trac_smtp_from:
[304]	417	self.author = "email2trac"
	418	else:
	419	self.author = self.email_addr
	420
[194]	421	if self.IGNORE_TRAC_USER_SETTINGS:
	422	return
	423
	424	# Is this a registered user, use email address as search key:
	425	# result:
	426	# u : login name
	427	# n : Name that the user has set in the settings tab
	428	# e : email address that the user has set in the settings tab
[45]	429	#
[194]	430	users = [ (u,n,e) for (u, n, e) in self.env.get_known_users(self.db)
[250]	431	if e and (e.lower() == self.email_addr.lower()) ]
[43]	432
[45]	433	if len(users) == 1:
[194]	434	self.email_from = users[0][0]
[250]	435	self.author = users[0][0]
[45]	436
[72]	437	def set_reply_fields(self, ticket, message):
	438	"""
	439	Set all the right fields for a new ticket
	440	"""
[299]	441	if self.DEBUG:
	442	print 'TD: set_reply_fields'
[72]	443
[270]	444	## Only use name or email adress
	445	#ticket['reporter'] = self.email_from
	446	ticket['reporter'] = self.author
	447
	448
[45]	449	# Put all CC-addresses in ticket CC field
[43]	450	#
	451	if self.REPLY_ALL:
	452
[299]	453	email_cc = ''
	454
	455	cc_addrs = email.Utils.getaddresses( message.get_all('cc', []) )
	456
	457	if not cc_addrs:
[105]	458	return
[43]	459
[299]	460	## Build a list of forbidden CC addresses
	461	#
[300]	462	#to_addrs = email.Utils.getaddresses( message.get_all('to', []) )
	463	#to_list = list()
	464	#for n,e in to_addrs:
	465	# to_list.append(e)
[299]	466
[43]	467	# Remove reporter email address if notification is
	468	# on
	469	#
	470	if self.notification:
	471	try:
[299]	472	cc_addrs.remove((self.author, self.email_addr))
[43]	473	except ValueError, detail:
	474	pass
	475
[299]	476	for name,addr in cc_addrs:
	477
	478	## Prevent mail loop
	479	#
[300]	480	#if addr in to_list:
[304]	481
	482	if addr == self.trac_smtp_from:
[299]	483	if self.DEBUG:
	484	print "Skipping %s mail address for CC-field" %(addr)
	485	continue
[43]	486
[299]	487	if email_cc:
	488	email_cc = '%s, %s' %(email_cc, addr)
	489	else:
	490	email_cc = addr
[96]	491
[299]	492	if email_cc:
	493	if self.DEBUG:
	494	print 'TD: set_reply_fields: %s' %email_cc
	495
	496	ticket['cc'] = self.email_to_unicode(email_cc)
	497
[310]	498	def debug_body(self, message_body, tempfile=False):
	499	if tempfile:
	500	import tempfile
	501	body_file = tempfile.mktemp('.email2trac')
	502	else:
	503	body_file = os.path.join(self.TMPDIR, 'body.txt')
	504
	505	print 'TD: writing body (%s)' % body_file
	506	fx = open(body_file, 'wb')
	507	if not message_body:
	508	message_body = '(None)'
	509
	510	message_body = message_body.encode('utf-8')
	511	#message_body = unicode(message_body, 'iso-8859-15')
	512
	513	fx.write(message_body)
	514	fx.close()
	515	try:
	516	os.chmod(body_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
	517	except OSError:
	518	pass
	519
	520	def debug_attachments(self, message_parts):
[317]	521	"""
	522	"""
	523	if self.VERBOSE:
	524	print "VB: debug_attachments"
	525
[310]	526	n = 0
	527	for part in message_parts:
	528	# Skip inline text parts
	529	if not isinstance(part, tuple):
	530	continue
	531
	532	(original, filename, part) = part
	533
	534	n = n + 1
	535	print 'TD: part%d: Content-Type: %s' % (n, part.get_content_type())
	536	print 'TD: part%d: filename: %s' % (n, part.get_filename())
	537
	538	part_file = os.path.join(self.TMPDIR, filename)
	539	#part_file = '/var/tmp/part%d' % n
	540	print 'TD: writing part%d (%s)' % (n,part_file)
	541	fx = open(part_file, 'wb')
	542	text = part.get_payload(decode=1)
	543	if not text:
	544	text = '(None)'
	545	fx.write(text)
	546	fx.close()
	547	try:
	548	os.chmod(part_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
	549	except OSError:
	550	pass
	551
[96]	552	def save_email_for_debug(self, message, tempfile=False):
[309]	553
[96]	554	if tempfile:
	555	import tempfile
	556	msg_file = tempfile.mktemp('.email2trac')
	557	else:
[173]	558	#msg_file = '/var/tmp/msg.txt'
	559	msg_file = os.path.join(self.TMPDIR, 'msg.txt')
	560
[44]	561	print 'TD: saving email to %s' % msg_file
	562	fx = open(msg_file, 'wb')
	563	fx.write('%s' % message)
	564	fx.close()
	565	try:
	566	os.chmod(msg_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
	567	except OSError:
	568	pass
	569
[309]	570	message_parts = self.get_message_parts(message)
	571	message_parts = self.unique_attachment_names(message_parts)
	572	body_text = self.body_text(message_parts)
	573	self.debug_body(body_text, True)
	574	self.debug_attachments(message_parts)
	575
[288]	576	def str_to_dict(self, s):
[164]	577	"""
[288]	578	Transfrom a string of the form [<key>=<value>]+ to dict[<key>] = <value>
[164]	579	"""
	580
[297]	581	fields = string.split(s, self.SUBJECT_FIELD_SEPARATOR)
[262]	582
[164]	583	result = dict()
	584	for field in fields:
	585	try:
[262]	586	index, value = string.split(field, '=')
[169]	587
	588	# We can not change the description of a ticket via the subject
	589	# line. The description is the body of the email
	590	#
	591	if index.lower() in ['description']:
	592	continue
	593
[164]	594	if value:
[165]	595	result[index.lower()] = value
[169]	596
[164]	597	except ValueError:
	598	pass
[165]	599	return result
[167]	600
[202]	601	def update_ticket_fields(self, ticket, user_dict, use_default=None):
	602	"""
	603	This will update the ticket fields. It will check if the
	604	given fields are known and if the right values are specified
	605	It will only update the ticket field value:
[169]	606	- If the field is known
[202]	607	- If the value supplied is valid for the ticket field.
	608	If not then there are two options:
	609	1) Skip the value (use_default=None)
	610	2) Set default value for field (use_default=1)
[169]	611	"""
[301]	612	if self.DEBUG:
	613	print "TD: update_ticket_fields"
[169]	614
	615	# Build a system dictionary from the ticket fields
	616	# with field as index and option as value
	617	#
	618	sys_dict = dict()
	619	for field in ticket.fields:
[167]	620	try:
[169]	621	sys_dict[field['name']] = field['options']
	622
[167]	623	except KeyError:
[169]	624	sys_dict[field['name']] = None
[167]	625	pass
[169]	626
[301]	627	## Check user supplied fields an compare them with the
[169]	628	# system one's
	629	#
	630	for field,value in user_dict.items():
[202]	631	if self.DEBUG >= 10:
	632	print 'user_field\t %s = %s' %(field,value)
[169]	633
[301]	634	## To prevent mail loop
	635	#
	636	if field == 'cc':
	637
	638	cc_list = user_dict['cc'].split(',')
	639
[304]	640	if self.trac_smtp_from in cc_list:
[301]	641	if self.DEBUG > 10:
[304]	642	print 'TD: MAIL LOOP: %s is not allowed as CC address' %(self.trac_smtp_from)
	643	cc_list.remove(self.trac_smtp_from)
[301]	644
	645	value = ','.join(cc_list)
	646
	647
[169]	648	if sys_dict.has_key(field):
	649
	650	# Check if value is an allowed system option, if TypeError then
	651	# every value is allowed
	652	#
	653	try:
	654	if value in sys_dict[field]:
	655	ticket[field] = value
[202]	656	else:
	657	# Must we set a default if value is not allowed
	658	#
	659	if use_default:
	660	value = self.get_config('ticket', 'default_%s' %(field) )
	661	ticket[field] = value
[169]	662
	663	except TypeError:
	664	ticket[field] = value
[202]	665
	666	if self.DEBUG >= 10:
	667	print 'ticket_field\t %s = %s' %(field, ticket[field])
[169]	668
[260]	669	def ticket_update(self, m, id, spam):
[78]	670	"""
[79]	671	If the current email is a reply to an existing ticket, this function
	672	will append the contents of this email to that ticket, instead of
	673	creating a new one.
[78]	674	"""
[250]	675	if self.DEBUG:
[260]	676	print "TD: ticket_update: %s" %id
[202]	677
[164]	678	# Must we update ticket fields
	679	#
[220]	680	update_fields = dict()
[165]	681	try:
[260]	682	id, keywords = string.split(id, '?')
[262]	683
	684	# Skip the last ':' character
	685	#
	686	keywords = keywords[:-1]
[220]	687	update_fields = self.str_to_dict(keywords)
[165]	688
	689	# Strip '#'
	690	#
[260]	691	self.id = int(id[1:])
[165]	692
[260]	693	except ValueError:
[165]	694	# Strip '#' and ':'
	695	#
[260]	696	self.id = int(id[1:-1])
[164]	697
[71]	698
[194]	699	# When is the change committed
	700	#
	701	if self.VERSION == 0.11:
	702	utc = UTC()
	703	when = datetime.now(utc)
	704	else:
	705	when = int(time.time())
[77]	706
[172]	707	try:
[253]	708	tkt = Ticket(self.env, self.id, self.db)
[172]	709	except util.TracError, detail:
[253]	710	# Not a valid ticket
	711	self.id = None
[172]	712	return False
[126]	713
[288]	714	# How many changes has this ticket
	715	cnum = len(tkt.get_changelog())
	716
	717
[220]	718	# reopen the ticket if it is was closed
	719	# We must use the ticket workflow framework
	720	#
[320]	721	if tkt['status'] in ['closed'] and self.EMAIL_TRIGGERS_WORKFLOW:
[220]	722
[257]	723	#print controller.actions['reopen']
	724	#
	725	# As reference
	726	# req = Mock(href=Href('/'), abs_href=Href('http://www.example.com/'), authname='anonymous', perm=MockPerm(), args={})
	727	#
	728	#a = controller.render_ticket_action_control(req, tkt, 'reopen')
	729	#print 'controller : ', a
	730	#
	731	#b = controller.get_all_status()
	732	#print 'get all status: ', b
	733	#
	734	#b = controller.get_ticket_changes(req, tkt, 'reopen')
	735	#print 'get_ticket_changes :', b
	736
[288]	737	if self.WORKFLOW and (self.VERSION in [0.11]) :
[257]	738	from trac.ticket.default_workflow import ConfigurableTicketWorkflow
	739	from trac.test import Mock, MockPerm
	740
	741	req = Mock(authname='anonymous', perm=MockPerm(), args={})
	742
	743	controller = ConfigurableTicketWorkflow(self.env)
	744	fields = controller.get_ticket_changes(req, tkt, self.WORKFLOW)
	745
	746	if self.DEBUG:
	747	print 'TD: Workflow ticket update fields: ', fields
	748
	749	for key in fields.keys():
	750	tkt[key] = fields[key]
	751
	752	else:
	753	tkt['status'] = 'reopened'
	754	tkt['resolution'] = ''
	755
[309]	756	# Must we update some ticket fields properties via subjectline
[172]	757	#
[220]	758	if update_fields:
	759	self.update_ticket_fields(tkt, update_fields)
[166]	760
[236]	761	message_parts = self.get_message_parts(m)
[253]	762	message_parts = self.unique_attachment_names(message_parts)
[210]	763
[309]	764	# Must we update some ticket fields properties via body_text
	765	#
	766	if self.properties:
	767	self.update_ticket_fields(tkt, self.properties)
	768
[177]	769	if self.EMAIL_HEADER:
[236]	770	message_parts.insert(0, self.email_header_txt(m))
[76]	771
[236]	772	body_text = self.body_text(message_parts)
	773
[309]	774	if body_text.strip() or update_fields or self.properties:
[250]	775	if self.DRY_RUN:
[288]	776	print 'DRY_RUN: tkt.save_changes(self.author, body_text, ticket_change_number) ', self.author, cnum
[250]	777	else:
[288]	778	tkt.save_changes(self.author, body_text, when, None, str(cnum))
	779
[219]	780
[129]	781	if self.VERSION == 0.9:
[321]	782	error_with_attachments = self.attachments(message_parts, True)
[129]	783	else:
[321]	784	error_with_attachments = self.attachments(message_parts)
[76]	785
[204]	786	if self.notification and not spam:
[253]	787	self.notify(tkt, False, when)
[72]	788
[71]	789	return True
	790
[202]	791	def set_ticket_fields(self, ticket):
[77]	792	"""
[202]	793	set the ticket fields to value specified
	794	- /etc/email2trac.conf with <prefix>_<field>
	795	- trac default values, trac.ini
	796	"""
	797	user_dict = dict()
	798
	799	for field in ticket.fields:
	800
	801	name = field['name']
	802
[215]	803	# skip some fields like resolution
	804	#
	805	if name in [ 'resolution' ]:
	806	continue
	807
[202]	808	# default trac value
	809	#
[233]	810	if not field.get('custom'):
	811	value = self.get_config('ticket', 'default_%s' %(name) )
	812	else:
	813	value = field.get('value')
	814	options = field.get('options')
[234]	815	if value and options and value not in options:
[233]	816	value = options[int(value)]
	817
[202]	818	if self.DEBUG > 10:
	819	print 'trac.ini name %s = %s' %(name, value)
	820
[206]	821	prefix = self.parameters['ticket_prefix']
[202]	822	try:
[206]	823	value = self.parameters['%s_%s' %(prefix, name)]
[202]	824	if self.DEBUG > 10:
	825	print 'email2trac.conf %s = %s ' %(name, value)
	826
	827	except KeyError, detail:
	828	pass
	829
	830	if self.DEBUG:
	831	print 'user_dict[%s] = %s' %(name, value)
	832
	833	user_dict[name] = value
	834
	835	self.update_ticket_fields(ticket, user_dict, use_default=1)
	836
	837	# Set status ticket
	838	#`
	839	ticket['status'] = 'new'
	840
	841
	842
[262]	843	def new_ticket(self, msg, subject, spam, set_fields = None):
[202]	844	"""
[77]	845	Create a new ticket
	846	"""
[250]	847	if self.DEBUG:
	848	print "TD: new_ticket"
	849
[41]	850	tkt = Ticket(self.env)
[202]	851	self.set_ticket_fields(tkt)
	852
	853	# Old style setting for component, will be removed
	854	#
[204]	855	if spam:
	856	tkt['component'] = 'Spam'
	857
[206]	858	elif self.parameters.has_key('component'):
	859	tkt['component'] = self.parameters['component']
[201]	860
[22]	861	if not msg['Subject']:
[151]	862	tkt['summary'] = u'(No subject)'
[22]	863	else:
[264]	864	tkt['summary'] = subject
[22]	865
[72]	866	self.set_reply_fields(tkt, msg)
[22]	867
[262]	868	if set_fields:
	869	rest, keywords = string.split(set_fields, '?')
	870
	871	if keywords:
	872	update_fields = self.str_to_dict(keywords)
	873	self.update_ticket_fields(tkt, update_fields)
	874
[45]	875	# produce e-mail like header
	876	#
[22]	877	head = ''
	878	if self.EMAIL_HEADER > 0:
	879	head = self.email_header_txt(msg)
[296]	880
[236]	881	message_parts = self.get_message_parts(msg)
[309]	882
	883	# Must we update some ticket fields properties via body_text
	884	#
	885	if self.properties:
	886	self.update_ticket_fields(tkt, self.properties)
	887
[296]	888	if self.DEBUG:
	889	print 'TD: self.get_message_parts ',
	890	print message_parts
	891
[236]	892	message_parts = self.unique_attachment_names(message_parts)
[296]	893	if self.DEBUG:
	894	print 'TD: self.unique_attachment_names',
	895	print message_parts
[236]	896
	897	if self.EMAIL_HEADER > 0:
	898	message_parts.insert(0, self.email_header_txt(msg))
	899
	900	body_text = self.body_text(message_parts)
[45]	901
[236]	902	tkt['description'] = body_text
[90]	903
[182]	904	#when = int(time.time())
[192]	905	#
[182]	906	utc = UTC()
	907	when = datetime.now(utc)
[45]	908
[253]	909	if not self.DRY_RUN:
	910	self.id = tkt.insert()
[273]	911
[90]	912	changed = False
	913	comment = ''
[77]	914
[273]	915	# some routines in trac are dependend on ticket id
	916	# like alternate notify template
	917	#
	918	if self.notify_template:
[274]	919	tkt['id'] = self.id
[273]	920	changed = True
	921
[295]	922	## Rewrite the description if we have mailto enabled
[45]	923	#
[72]	924	if self.MAILTO:
[100]	925	changed = True
[142]	926	comment = u'\nadded mailto line\n'
[253]	927	mailto = self.html_mailto_link( m['Subject'], body_text)
	928
[213]	929	tkt['description'] = u'%s\r\n%s%s\r\n' \
[142]	930	%(head, mailto, body_text)
[295]	931
	932	## Save the attachments to the ticket
	933	#
[319]	934	error_with_attachments = self.attachments(message_parts)
[295]	935
[319]	936	if error_with_attachments:
	937	changed = True
	938	comment = '%s\n%s\n' %(comment, error_with_attachments)
[45]	939
[90]	940	if changed:
[204]	941	if self.DRY_RUN:
[250]	942	print 'DRY_RUN: tkt.save_changes(self.author, comment) ', self.author
[201]	943	else:
	944	tkt.save_changes(self.author, comment)
	945	#print tkt.get_changelog(self.db, when)
[90]	946
[250]	947	if self.notification and not spam:
[253]	948	self.notify(tkt, True)
[45]	949
[260]	950
	951	def blog(self, id):
	952	"""
	953	The blog create/update function
	954	"""
	955	# import the modules
	956	#
	957	from tracfullblog.core import FullBlogCore
[312]	958	from tracfullblog.model import BlogPost, BlogComment
	959	from trac.test import Mock, MockPerm
[260]	960
	961	# instantiate blog core
	962	blog = FullBlogCore(self.env)
[312]	963	req = Mock(authname='anonymous', perm=MockPerm(), args={})
	964
[260]	965	if id:
	966
	967	# update blog
	968	#
[268]	969	comment = BlogComment(self.env, id)
[260]	970	comment.author = self.author
[312]	971
	972	message_parts = self.get_message_parts(m)
	973	comment.comment = self.body_text(message_parts)
	974
[260]	975	blog.create_comment(req, comment)
	976
	977	else:
	978	# create blog
	979	#
	980	import time
	981	post = BlogPost(self.env, 'blog_'+time.strftime("%Y%m%d%H%M%S", time.gmtime()))
	982
	983	#post = BlogPost(self.env, blog._get_default_postname(self.env))
	984
	985	post.author = self.author
	986	post.title = self.email_to_unicode(m['Subject'])
[312]	987
	988	message_parts = self.get_message_parts(m)
	989	post.body = self.body_text(message_parts)
[260]	990
	991	blog.create_post(req, post, self.author, u'Created by email2trac', False)
	992
[309]	993	def save_message_for_debug(self):
	994	"""
	995	Save the messages. So we can use it for debug purposes
	996	"""
	997
[260]	998
[77]	999	def parse(self, fp):
[96]	1000	global m
	1001
[77]	1002	m = email.message_from_file(fp)
[239]	1003
[77]	1004	if not m:
[221]	1005	if self.DEBUG:
[250]	1006	print "TD: This is not a valid email message format"
[77]	1007	return
[239]	1008
	1009	# Work around lack of header folding in Python; see http://bugs.python.org/issue4696
[316]	1010	try:
	1011	m.replace_header('Subject', m['Subject'].replace('\r', '').replace('\n', ''))
	1012	except AttributeError, detail:
	1013	pass
[239]	1014
[77]	1015	if self.DEBUG > 1: # save the entire e-mail message text
[219]	1016	self.save_email_for_debug(m, True)
[77]	1017
	1018	self.db = self.env.get_db_cnx()
[194]	1019	self.get_sender_info(m)
[152]	1020
[221]	1021	if not self.email_header_acl('white_list', self.email_addr, True):
	1022	if self.DEBUG > 1 :
	1023	print 'Message rejected : %s not in white list' %(self.email_addr)
	1024	return False
[77]	1025
[221]	1026	if self.email_header_acl('black_list', self.email_addr, False):
	1027	if self.DEBUG > 1 :
	1028	print 'Message rejected : %s in black list' %(self.email_addr)
	1029	return False
	1030
[227]	1031	if not self.email_header_acl('recipient_list', self.to_email_addr, True):
[226]	1032	if self.DEBUG > 1 :
	1033	print 'Message rejected : %s not in recipient list' %(self.to_email_addr)
	1034	return False
	1035
[204]	1036	# If drop the message
[194]	1037	#
[204]	1038	if self.spam(m) == 'drop':
[194]	1039	return False
	1040
[204]	1041	elif self.spam(m) == 'spam':
	1042	spam_msg = True
	1043	else:
	1044	spam_msg = False
	1045
[77]	1046	if self.get_config('notification', 'smtp_enabled') in ['true']:
	1047	self.notification = 1
	1048	else:
	1049	self.notification = 0
	1050
[304]	1051
[260]	1052	# Check if FullBlogPlugin is installed
[77]	1053	#
[260]	1054	blog_enabled = None
	1055	if self.get_config('components', 'tracfullblog.*') in ['enabled']:
	1056	blog_enabled = True
	1057
	1058	if not m['Subject']:
	1059	return False
	1060	else:
	1061	subject = self.email_to_unicode(m['Subject'])
[77]	1062
[260]	1063	#
	1064	# [hic] #1529: Re: LRZ
	1065	# [hic] #1529?owner=bas,priority=medium: Re: LRZ
	1066	#
	1067	TICKET_RE = re.compile(r"""
	1068	(?P<blog>blog:(?P<blog_id>\w*))
[262]	1069	\|(?P<new_fields>[#][?].*)
	1070	\|(?P<reply>[#][\d]+:)
	1071	\|(?P<reply_fields>[#][\d]+\?.*?:)
[260]	1072	""", re.VERBOSE)
[77]	1073
[265]	1074	# Find out if this is a ticket or a blog
	1075	#
[260]	1076	result = TICKET_RE.search(subject)
	1077
	1078	if result:
[309]	1079	if result.group('blog'):
	1080	if blog_enabled:
	1081	self.blog(result.group('blog_id'))
	1082	else:
	1083	if self.DEBUG:
	1084	print "Fullblog plugin is not installed"
	1085	return
[260]	1086
	1087	# update ticket + fields
	1088	#
[262]	1089	if result.group('reply_fields') and self.TICKET_UPDATE:
	1090	self.ticket_update(m, result.group('reply_fields'), spam_msg)
[260]	1091
	1092	# Update ticket
	1093	#
[262]	1094	elif result.group('reply') and self.TICKET_UPDATE:
	1095	self.ticket_update(m, result.group('reply'), spam_msg)
[260]	1096
[262]	1097	# New ticket + fields
	1098	#
	1099	elif result.group('new_fields'):
	1100	self.new_ticket(m, subject[:result.start('new_fields')], spam_msg, result.group('new_fields'))
	1101
[260]	1102	# Create ticket
	1103	#
	1104	else:
[262]	1105	self.new_ticket(m, subject, spam_msg)
[260]	1106
[136]	1107	def strip_signature(self, text):
	1108	"""
	1109	Strip signature from message, inspired by Mailman software
	1110	"""
	1111	body = []
	1112	for line in text.splitlines():
	1113	if line == '-- ':
	1114	break
	1115	body.append(line)
	1116
	1117	return ('\n'.join(body))
	1118
[231]	1119	def reflow(self, text, delsp = 0):
	1120	"""
	1121	Reflow the message based on the format="flowed" specification (RFC 3676)
	1122	"""
	1123	flowedlines = []
	1124	quotelevel = 0
	1125	prevflowed = 0
	1126
	1127	for line in text.splitlines():
	1128	from re import match
	1129
	1130	# Figure out the quote level and the content of the current line
	1131	m = match('(>)( ?)(.)', line)
	1132	linequotelevel = len(m.group(1))
	1133	line = m.group(3)
	1134
	1135	# Determine whether this line is flowed
	1136	if line and line != '-- ' and line[-1] == ' ':
	1137	flowed = 1
	1138	else:
	1139	flowed = 0
	1140
	1141	if flowed and delsp and line and line[-1] == ' ':
	1142	line = line[:-1]
	1143
	1144	# If the previous line is flowed, append this line to it
	1145	if prevflowed and line != '-- ' and linequotelevel == quotelevel:
	1146	flowedlines[-1] += line
	1147	# Otherwise, start a new line
	1148	else:
	1149	flowedlines.append('>' * linequotelevel + line)
	1150
	1151	prevflowed = flowed
	1152
	1153
	1154	return '\n'.join(flowedlines)
	1155
[191]	1156	def strip_quotes(self, text):
[193]	1157	"""
	1158	Strip quotes from message by Nicolas Mendoza
	1159	"""
	1160	body = []
	1161	for line in text.splitlines():
	1162	if line.startswith(self.EMAIL_QUOTE):
	1163	continue
	1164	body.append(line)
[151]	1165
[193]	1166	return ('\n'.join(body))
[191]	1167
[309]	1168	def inline_properties(self, text):
	1169	"""
	1170	Parse text if we use inline keywords to set ticket fields
	1171	"""
	1172	if self.DEBUG:
	1173	print 'TD: inline_properties function'
	1174
	1175	properties = dict()
	1176	body = list()
	1177
	1178	INLINE_EXP = re.compile('\s[@]\s([a-zA-Z]+)\s:(.)$')
	1179
	1180	for line in text.splitlines():
	1181	match = INLINE_EXP.match(line)
	1182	if match:
	1183	keyword, value = match.groups()
	1184	self.properties[keyword] = value.strip()
[311]	1185	if self.DEBUG:
	1186	print "TD: inline properties: %s : %s" %(keyword,value)
[309]	1187	else:
	1188	body.append(line)
	1189
	1190	return '\n'.join(body)
	1191
	1192
[154]	1193	def wrap_text(self, text, replace_whitespace = False):
[151]	1194	"""
[191]	1195	Will break a lines longer then given length into several small
	1196	lines of size given length
[151]	1197	"""
	1198	import textwrap
[154]	1199
[151]	1200	LINESEPARATOR = '\n'
[153]	1201	reformat = ''
[151]	1202
[154]	1203	for s in text.split(LINESEPARATOR):
	1204	tmp = textwrap.fill(s,self.USE_TEXTWRAP)
	1205	if tmp:
	1206	reformat = '%s\n%s' %(reformat,tmp)
	1207	else:
	1208	reformat = '%s\n' %reformat
[153]	1209
	1210	return reformat
	1211
[154]	1212	# Python2.4 and higher
	1213	#
	1214	#return LINESEPARATOR.join(textwrap.fill(s,width) for s in str.split(LINESEPARATOR))
	1215	#
	1216
	1217
[236]	1218	def get_message_parts(self, msg):
[45]	1219	"""
[236]	1220	parses the email message and returns a list of body parts and attachments
	1221	body parts are returned as strings, attachments are returned as tuples of (filename, Message object)
[45]	1222	"""
[317]	1223	if self.VERBOSE:
	1224	print "VB: get_message_parts()"
	1225
[309]	1226	message_parts = list()
[294]	1227
[278]	1228	ALTERNATIVE_MULTIPART = False
	1229
[22]	1230	for part in msg.walk():
[236]	1231	if self.DEBUG:
[278]	1232	print 'TD: Message part: Main-Type: %s' % part.get_content_maintype()
[236]	1233	print 'TD: Message part: Content-Type: %s' % part.get_content_type()
[278]	1234
	1235	## Check content type
[294]	1236	#
	1237	if part.get_content_type() in self.STRIP_CONTENT_TYPES:
[238]	1238
[294]	1239	if self.DEBUG:
	1240	print "TD: A %s attachment named '%s' was skipped" %(part.get_content_type(), part.get_filename())
[238]	1241
	1242	continue
	1243
[294]	1244	## Catch some mulitpart execptions
	1245	#
	1246	if part.get_content_type() == 'multipart/alternative':
[278]	1247	ALTERNATIVE_MULTIPART = True
	1248	continue
	1249
[294]	1250	## Skip multipart containers
[278]	1251	#
[45]	1252	if part.get_content_maintype() == 'multipart':
[278]	1253	if self.DEBUG:
	1254	print "TD: Skipping multipart container"
[22]	1255	continue
[278]	1256
[294]	1257	## 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"
	1258	#
[236]	1259	inline = self.inline_part(part)
	1260
[294]	1261	## Drop HTML message
	1262	#
[278]	1263	if ALTERNATIVE_MULTIPART and self.DROP_ALTERNATIVE_HTML_VERSION:
	1264	if part.get_content_type() == 'text/html':
	1265	if self.DEBUG:
	1266	print "TD: Skipping alternative HTML message"
	1267
	1268	ALTERNATIVE_MULTIPART = False
	1269	continue
	1270
[294]	1271	## Inline text parts are where the body is
	1272	#
[236]	1273	if part.get_content_type() == 'text/plain' and inline:
	1274	if self.DEBUG:
	1275	print 'TD: Inline body part'
	1276
[45]	1277	# Try to decode, if fails then do not decode
	1278	#
[90]	1279	body_text = part.get_payload(decode=1)
[45]	1280	if not body_text:
[90]	1281	body_text = part.get_payload(decode=0)
[231]	1282
[232]	1283	format = email.Utils.collapse_rfc2231_value(part.get_param('Format', 'fixed')).lower()
	1284	delsp = email.Utils.collapse_rfc2231_value(part.get_param('DelSp', 'no')).lower()
[231]	1285
	1286	if self.REFLOW and not self.VERBATIM_FORMAT and format == 'flowed':
	1287	body_text = self.reflow(body_text, delsp == 'yes')
[154]	1288
[136]	1289	if self.STRIP_SIGNATURE:
	1290	body_text = self.strip_signature(body_text)
[22]	1291
[191]	1292	if self.STRIP_QUOTES:
	1293	body_text = self.strip_quotes(body_text)
	1294
[309]	1295	if self.INLINE_PROPERTIES:
	1296	body_text = self.inline_properties(body_text)
	1297
[148]	1298	if self.USE_TEXTWRAP:
[151]	1299	body_text = self.wrap_text(body_text)
[148]	1300
[294]	1301	## Get contents charset (iso-8859-15 if not defined in mail headers)
[45]	1302	#
[100]	1303	charset = part.get_content_charset()
[102]	1304	if not charset:
	1305	charset = 'iso-8859-15'
	1306
[89]	1307	try:
[96]	1308	ubody_text = unicode(body_text, charset)
[100]	1309
	1310	except UnicodeError, detail:
[96]	1311	ubody_text = unicode(body_text, 'iso-8859-15')
[89]	1312
[100]	1313	except LookupError, detail:
[139]	1314	ubody_text = 'ERROR: Could not find charset: %s, please install' %(charset)
[100]	1315
[236]	1316	if self.VERBATIM_FORMAT:
	1317	message_parts.append('{{{\r\n%s\r\n}}}' %ubody_text)
	1318	else:
	1319	message_parts.append('%s' %ubody_text)
	1320	else:
	1321	if self.DEBUG:
[315]	1322	try:
	1323	print 'TD: Filename: %s' % part.get_filename()
	1324	except UnicodeEncodeError, detail:
	1325	print 'TD: Filename: Can not be printed due to non-ascci characters'
[22]	1326
[317]	1327	## Convert 7-bit filename to 8 bits value
	1328	#
	1329	filename = self.email_to_unicode(part.get_filename())
	1330	message_parts.append((filename, part))
[236]	1331
	1332	return message_parts
	1333
[253]	1334	def unique_attachment_names(self, message_parts):
[296]	1335	"""
	1336	"""
[236]	1337	renamed_parts = []
	1338	attachment_names = set()
[296]	1339
[236]	1340	for part in message_parts:
	1341
[296]	1342	## If not an attachment, leave it alone
	1343	#
[236]	1344	if not isinstance(part, tuple):
	1345	renamed_parts.append(part)
	1346	continue
	1347
	1348	(filename, part) = part
[295]	1349
[296]	1350	## If no filename, use a default one
	1351	#
	1352	if not filename:
[236]	1353	filename = 'untitled-part'
[22]	1354
[242]	1355	# Guess the extension from the content type, use non strict mode
	1356	# some additional non-standard but commonly used MIME types
	1357	# are also recognized
	1358	#
	1359	ext = mimetypes.guess_extension(part.get_content_type(), False)
[236]	1360	if not ext:
	1361	ext = '.bin'
[22]	1362
[236]	1363	filename = '%s%s' % (filename, ext)
[22]	1364
[296]	1365	# We now use the attachment insert function
	1366	#
	1367	## Discard relative paths in attachment names
	1368	#
	1369	#filename = filename.replace('\\', '/').replace(':', '/')
	1370	#filename = os.path.basename(filename)
	1371	#
[236]	1372	# We try to normalize the filename to utf-8 NFC if we can.
	1373	# Files uploaded from OS X might be in NFD.
	1374	# Check python version and then try it
	1375	#
[296]	1376	#if sys.version_info[0] > 2 or (sys.version_info[0] == 2 and sys.version_info[1] >= 3):
	1377	# try:
	1378	# filename = unicodedata.normalize('NFC', unicode(filename, 'utf-8')).encode('utf-8')
	1379	# except TypeError:
	1380	# pass
[100]	1381
[236]	1382	# Make the filename unique for this ticket
	1383	num = 0
	1384	unique_filename = filename
[296]	1385	dummy_filename, ext = os.path.splitext(filename)
[134]	1386
[253]	1387	while unique_filename in attachment_names or self.attachment_exists(unique_filename):
[236]	1388	num += 1
[296]	1389	unique_filename = "%s-%s%s" % (dummy_filename, num, ext)
[236]	1390
	1391	if self.DEBUG:
	1392	print 'TD: Attachment with filename %s will be saved as %s' % (filename, unique_filename)
[100]	1393
[236]	1394	attachment_names.add(unique_filename)
	1395
	1396	renamed_parts.append((filename, unique_filename, part))
[296]	1397
[236]	1398	return renamed_parts
	1399
	1400	def inline_part(self, part):
	1401	return part.get_param('inline', None, 'Content-Disposition') == '' or not part.has_key('Content-Disposition')
	1402
	1403
[253]	1404	def attachment_exists(self, filename):
[250]	1405
	1406	if self.DEBUG:
[253]	1407	print "TD: attachment_exists: Ticket number : %s, Filename : %s" %(self.id, filename)
[250]	1408
	1409	# We have no valid ticket id
	1410	#
[253]	1411	if not self.id:
[236]	1412	return False
[250]	1413
[236]	1414	try:
[253]	1415	att = attachment.Attachment(self.env, 'ticket', self.id, filename)
[236]	1416	return True
[250]	1417	except attachment.ResourceNotFound:
[236]	1418	return False
	1419
	1420	def body_text(self, message_parts):
	1421	body_text = []
	1422
	1423	for part in message_parts:
	1424	# Plain text part, append it
	1425	if not isinstance(part, tuple):
	1426	body_text.extend(part.strip().splitlines())
	1427	body_text.append("")
	1428	continue
	1429
	1430	(original, filename, part) = part
	1431	inline = self.inline_part(part)
	1432
	1433	if part.get_content_maintype() == 'image' and inline:
	1434	body_text.append('[[Image(%s)]]' % filename)
	1435	body_text.append("")
	1436	else:
	1437	body_text.append('[attachment:"%s"]' % filename)
	1438	body_text.append("")
	1439
	1440	body_text = '\r\n'.join(body_text)
	1441	return body_text
	1442
[253]	1443	def notify(self, tkt, new=True, modtime=0):
[79]	1444	"""
	1445	A wrapper for the TRAC notify function. So we can use templates
	1446	"""
[250]	1447	if self.DRY_RUN:
	1448	print 'DRY_RUN: self.notify(tkt, True) ', self.author
	1449	return
[41]	1450	try:
	1451	# create false {abs_}href properties, to trick Notify()
	1452	#
[193]	1453	if not self.VERSION == 0.11:
[192]	1454	self.env.abs_href = Href(self.get_config('project', 'url'))
	1455	self.env.href = Href(self.get_config('project', 'url'))
[22]	1456
[41]	1457	tn = TicketNotifyEmail(self.env)
[213]	1458
[42]	1459	if self.notify_template:
[222]	1460
[221]	1461	if self.VERSION == 0.11:
[222]	1462
[221]	1463	from trac.web.chrome import Chrome
[222]	1464
	1465	if self.notify_template_update and not new:
	1466	tn.template_name = self.notify_template_update
	1467	else:
	1468	tn.template_name = self.notify_template
	1469
[221]	1470	tn.template = Chrome(tn.env).load_template(tn.template_name, method='text')
	1471
	1472	else:
[222]	1473
[221]	1474	tn.template_name = self.notify_template;
[42]	1475
[77]	1476	tn.notify(tkt, new, modtime)
[41]	1477
	1478	except Exception, e:
[253]	1479	print 'TD: Failure sending notification on creation of ticket #%s: %s' %(self.id, e)
[41]	1480
[253]	1481	def html_mailto_link(self, subject, body):
	1482	"""
	1483	This function returns a HTML mailto tag with the ticket id and author email address
	1484	"""
[72]	1485	if not self.author:
[143]	1486	author = self.email_addr
[22]	1487	else:
[142]	1488	author = self.author
[22]	1489
[253]	1490	# use urllib to escape the chars
[22]	1491	#
[288]	1492	s = 'mailto:%s?Subject=%s&Cc=%s' %(
[74]	1493	urllib.quote(self.email_addr),
[253]	1494	urllib.quote('Re: #%s: %s' %(self.id, subject)),
[74]	1495	urllib.quote(self.MAILTO_CC)
	1496	)
	1497
[290]	1498	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)
[288]	1499	return s
[22]	1500
[253]	1501	def attachments(self, message_parts, update=False):
[79]	1502	'''
	1503	save any attachments as files in the ticket's directory
	1504	'''
[237]	1505	if self.DRY_RUN:
[250]	1506	print "DRY_RUN: no attachments saved"
[237]	1507	return ''
	1508
[22]	1509	count = 0
[152]	1510
	1511	# Get Maxium attachment size
	1512	#
	1513	max_size = int(self.get_config('attachment', 'max_size'))
[319]	1514	status = None
[236]	1515
	1516	for part in message_parts:
	1517	# Skip body parts
	1518	if not isinstance(part, tuple):
[22]	1519	continue
[236]	1520
	1521	(original, filename, part) = part
[48]	1522	#
[172]	1523	# Must be tuneables HvB
	1524	#
[236]	1525	path, fd = util.create_unique_file(os.path.join(self.TMPDIR, filename))
[22]	1526	text = part.get_payload(decode=1)
	1527	if not text:
	1528	text = '(None)'
[48]	1529	fd.write(text)
	1530	fd.close()
[22]	1531
[153]	1532	# get the file_size
[22]	1533	#
[48]	1534	stats = os.lstat(path)
[153]	1535	file_size = stats[stat.ST_SIZE]
[22]	1536
[152]	1537	# Check if the attachment size is allowed
	1538	#
[153]	1539	if (max_size != -1) and (file_size > max_size):
	1540	status = '%s\nFile %s is larger then allowed attachment size (%d > %d)\n\n' \
[236]	1541	%(status, original, file_size, max_size)
[152]	1542
	1543	os.unlink(path)
	1544	continue
	1545	else:
	1546	count = count + 1
	1547
[172]	1548	# Insert the attachment
[73]	1549	#
[242]	1550	fd = open(path, 'rb')
[253]	1551	att = attachment.Attachment(self.env, 'ticket', self.id)
[73]	1552
[172]	1553	# This will break the ticket_update system, the body_text is vaporized
	1554	# ;-(
	1555	#
	1556	if not update:
	1557	att.author = self.author
	1558	att.description = self.email_to_unicode('Added by email2trac')
[73]	1559
[236]	1560	att.insert(filename, fd, file_size)
[296]	1561
[172]	1562	#except util.TracError, detail:
	1563	# print detail
[73]	1564
[103]	1565	# Remove the created temporary filename
	1566	#
[172]	1567	fd.close()
[103]	1568	os.unlink(path)
	1569
[319]	1570	## return error
[77]	1571	#
[153]	1572	return status
[22]	1573
[77]	1574
[22]	1575	def mkdir_p(dir, mode):
	1576	'''do a mkdir -p'''
	1577
	1578	arr = string.split(dir, '/')
	1579	path = ''
	1580	for part in arr:
	1581	path = '%s/%s' % (path, part)
	1582	try:
	1583	stats = os.stat(path)
	1584	except OSError:
	1585	os.mkdir(path, mode)
	1586
	1587	def ReadConfig(file, name):
	1588	"""
	1589	Parse the config file
	1590	"""
	1591	if not os.path.isfile(file):
[79]	1592	print 'File %s does not exist' %file
[22]	1593	sys.exit(1)
	1594
[199]	1595	config = trac_config.Configuration(file)
[22]	1596
	1597	# Use given project name else use defaults
	1598	#
	1599	if name:
[199]	1600	sections = config.sections()
	1601	if not name in sections:
[79]	1602	print "Not a valid project name: %s" %name
[199]	1603	print "Valid names: %s" %sections
[22]	1604	sys.exit(1)
	1605
	1606	project = dict()
[199]	1607	for option, value in config.options(name):
	1608	project[option] = value
[22]	1609
	1610	else:
[270]	1611	# use some trac internals to get the defaults
[217]	1612	#
	1613	project = config.parser.defaults()
[22]	1614
	1615	return project
	1616
[87]	1617
[22]	1618	if __name__ == '__main__':
	1619	# Default config file
	1620	#
[24]	1621	configfile = '@email2trac_conf@'
[22]	1622	project = ''
	1623	component = ''
[202]	1624	ticket_prefix = 'default'
[204]	1625	dry_run = None
[317]	1626	verbose = None
[202]	1627
[87]	1628	ENABLE_SYSLOG = 0
[201]	1629
[204]	1630
[317]	1631	SHORT_OPT = 'chf:np:t:v'
	1632	LONG_OPT = ['component=', 'dry-run', 'help', 'file=', 'project=', 'ticket_prefix=', 'verbose']
[201]	1633
[22]	1634	try:
[201]	1635	opts, args = getopt.getopt(sys.argv[1:], SHORT_OPT, LONG_OPT)
[22]	1636	except getopt.error,detail:
	1637	print __doc__
	1638	print detail
	1639	sys.exit(1)
[87]	1640
[22]	1641	project_name = None
	1642	for opt,value in opts:
	1643	if opt in [ '-h', '--help']:
	1644	print __doc__
	1645	sys.exit(0)
	1646	elif opt in ['-c', '--component']:
	1647	component = value
	1648	elif opt in ['-f', '--file']:
	1649	configfile = value
[201]	1650	elif opt in ['-n', '--dry-run']:
[204]	1651	dry_run = True
[22]	1652	elif opt in ['-p', '--project']:
	1653	project_name = value
[202]	1654	elif opt in ['-t', '--ticket_prefix']:
	1655	ticket_prefix = value
[317]	1656	elif opt in ['-v', '--version']:
	1657	verbose = True
[87]	1658
[22]	1659	settings = ReadConfig(configfile, project_name)
	1660	if not settings.has_key('project'):
	1661	print __doc__
[79]	1662	print 'No Trac project is defined in the email2trac config file.'
[22]	1663	sys.exit(1)
[87]	1664
[22]	1665	if component:
	1666	settings['component'] = component
[202]	1667
	1668	# The default prefix for ticket values in email2trac.conf
	1669	#
	1670	settings['ticket_prefix'] = ticket_prefix
[206]	1671	settings['dry_run'] = dry_run
[317]	1672	settings['verbose'] = verbose
[87]	1673
[22]	1674	if settings.has_key('trac_version'):
[189]	1675	version = settings['trac_version']
[22]	1676	else:
	1677	version = trac_default_version
	1678
[189]	1679
[22]	1680	#debug HvB
	1681	#print settings
[189]	1682
[87]	1683	try:
[189]	1684	if version == '0.9':
[87]	1685	from trac import attachment
	1686	from trac.env import Environment
	1687	from trac.ticket import Ticket
	1688	from trac.web.href import Href
	1689	from trac import util
	1690	from trac.Notify import TicketNotifyEmail
[189]	1691	elif version == '0.10':
[87]	1692	from trac import attachment
	1693	from trac.env import Environment
	1694	from trac.ticket import Ticket
	1695	from trac.web.href import Href
	1696	from trac import util
[139]	1697	#
	1698	# return util.text.to_unicode(str)
	1699	#
[87]	1700	# see http://projects.edgewall.com/trac/changeset/2799
	1701	from trac.ticket.notification import TicketNotifyEmail
[199]	1702	from trac import config as trac_config
[189]	1703	elif version == '0.11':
[182]	1704	from trac import attachment
	1705	from trac.env import Environment
	1706	from trac.ticket import Ticket
	1707	from trac.web.href import Href
[199]	1708	from trac import config as trac_config
[182]	1709	from trac import util
[260]	1710
	1711
[182]	1712	#
	1713	# return util.text.to_unicode(str)
	1714	#
	1715	# see http://projects.edgewall.com/trac/changeset/2799
	1716	from trac.ticket.notification import TicketNotifyEmail
[189]	1717	else:
	1718	print 'TRAC version %s is not supported' %version
	1719	sys.exit(1)
	1720
	1721	if settings.has_key('enable_syslog'):
[190]	1722	if SYSLOG_AVAILABLE:
	1723	ENABLE_SYSLOG = float(settings['enable_syslog'])
[182]	1724
[291]	1725
	1726	# Must be set before environment is created
	1727	#
	1728	if settings.has_key('python_egg_cache'):
	1729	python_egg_cache = str(settings['python_egg_cache'])
	1730	os.environ['PYTHON_EGG_CACHE'] = python_egg_cache
	1731
[87]	1732	env = Environment(settings['project'], create=0)
[206]	1733	tktparser = TicketEmailParser(env, settings, float(version))
[87]	1734	tktparser.parse(sys.stdin)
[22]	1735
[87]	1736	# Catch all errors ans log to SYSLOG if we have enabled this
	1737	# else stdout
	1738	#
	1739	except Exception, error:
	1740	if ENABLE_SYSLOG:
	1741	syslog.openlog('email2trac', syslog.LOG_NOWAIT)
[187]	1742
[87]	1743	etype, evalue, etb = sys.exc_info()
	1744	for e in traceback.format_exception(etype, evalue, etb):
	1745	syslog.syslog(e)
[187]	1746
[87]	1747	syslog.closelog()
	1748	else:
	1749	traceback.print_exc()
[22]	1750
[97]	1751	if m:
[98]	1752	tktparser.save_email_for_debug(m, True)
[97]	1753
[249]	1754	sys.exit(1)
[22]	1755	# EOB

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

Download in other formats:

Original Format