ruby-msg 1.3.1 → 1.4.0

data/lib/mapi.rb

@@ -0,0 +1,109 @@
+require 'mapi/types'
+require 'mapi/property_set'
+
+module Mapi
+	VERSION = '1.4.0'
+
+	#
+	# Mapi::Item is the base class used for all mapi objects, and is purely a
+	# property set container
+	#
+	class Item
+		attr_reader :properties
+		alias props properties
+
+		# +properties+ should be a PropertySet instance.
+		def initialize properties
+			@properties = properties
+		end
+	end
+
+	# a general attachment class. is subclassed by Msg and Pst attachment classes
+	class Attachment < Item
+		def filename
+			props.attach_long_filename || props.attach_filename
+		end
+
+		def data
+			@embedded_msg || @embedded_ole || props.attach_data
+		end
+
+		# with new stream work, its possible to not have the whole thing in memory at one time,
+		# just to save an attachment
+		#
+		# a = msg.attachments.first
+		# a.save open(File.basename(a.filename || 'attachment'), 'wb') 
+		def save io
+			raise "can only save binary data blobs, not ole dirs" if @embedded_ole
+			data.each_read { |chunk| io << chunk }
+		end
+
+		def inspect
+			"#<#{self.class.to_s[/\w+$/]}" +
+				(filename ? " filename=#{filename.inspect}" : '') +
+				(@embedded_ole ? " embedded_type=#{@embedded_ole.embedded_type.inspect}" : '') + ">"
+		end
+	end
+	
+	class Recipient < Item
+		# some kind of best effort guess for converting to standard mime style format.
+		# there are some rules for encoding non 7bit stuff in mail headers. should obey
+		# that here, as these strings could be unicode
+		# email_address will be an EX:/ address (X.400?), unless external recipient. the
+		# other two we try first.
+		# consider using entry id for this too.
+		def name
+			name = props.transmittable_display_name || props.display_name
+			# dequote
+			name[/^'(.*)'/, 1] or name rescue nil
+		end
+
+		def email
+			props.smtp_address || props.org_email_addr || props.email_address
+		end
+
+		RECIPIENT_TYPES = { 0 => :orig, 1 => :to, 2 => :cc, 3 => :bcc }
+		def type
+			RECIPIENT_TYPES[props.recipient_type]
+		end
+
+		def to_s
+			if name = self.name and !name.empty? and email && name != email
+				%{"#{name}" <#{email}>}
+			else
+				email || name
+			end
+		end
+
+		def inspect
+			"#<#{self.class.to_s[/\w+$/]}:#{self.to_s.inspect}>"
+		end
+	end
+
+	# i refer to it as a message (as does mapi), although perhaps Item is better, as its a more general
+	# concept than a message, as used in Pst files. though maybe i'll switch to using
+	# Mapi::Object as the base class there.
+	#
+	# IMessage essentially, but there's also stuff like IMAPIFolder etc. so, for this to form
+	# basis for PST Item, it'd need to be more general.
+	class Message < Item
+		# these 2 collections should be provided by our subclasses
+		def attachments
+			raise NotImplementedError
+		end
+
+		def recipients
+			raise NotImplementedError
+		end
+		
+		def inspect
+			str = %w[message_class from to subject].map do |key|
+				" #{key}=#{props.send(key).inspect}"
+			end.compact.join
+			str << " recipients=#{recipients.inspect}"
+			str << " attachments=#{attachments.inspect}"
+			"#<#{self.class.to_s[/\w+$/]}#{str}>"
+		end
+	end
+end
+

data/lib/mapi/convert.rb

@@ -0,0 +1,61 @@
+# we have two different "backends" for note conversion. we're sticking with
+# the current (home grown) mime one until the tmail version is suitably
+# polished.
+require 'mapi/convert/note-mime'
+require 'mapi/convert/contact'
+
+module Mapi
+	class Message
+		CONVERSION_MAP = {
+			'text/x-vcard'   => [:to_vcard, 'vcf'],
+			'message/rfc822' => [:to_mime, 'eml'],
+			'text/plain'     => [:to_post, 'txt']
+			# ...
+		}
+
+		# get the mime type of the message. 
+		def mime_type
+			case props.message_class #.downcase <- have a feeling i saw other cased versions
+			when 'IPM.Contact'
+				# apparently "text/directory; profile=vcard" is what you're supposed to use
+				'text/x-vcard'
+			when 'IPM.Note'
+				'message/rfc822'
+			when 'IPM.Post'
+				'text/plain'
+			when 'IPM.StickyNote'
+				'text/plain' # hmmm....
+			else
+				Mapi::Log.warn 'unknown message_class - %p' % props.message_class
+				nil
+			end
+		end	
+
+		def convert
+			type = mime_type
+			unless pair = CONVERSION_MAP[type]
+				raise 'unable to convert message with mime type - %p' % type
+			end
+			send pair.first
+		end
+
+		# should probably be moved to mapi/convert/post
+		class Post
+			# not really sure what the pertinent properties are. we just do nothing for now...
+			def initialize message
+				@message = message
+			end
+
+			def to_s
+				# should maybe handle other types, like html body. need a better format for post
+				# probably anyway, cause a lot of meta data is getting chucked.
+				@message.props.body
+			end
+		end
+
+		def to_post
+			Post.new self
+		end
+	end
+end
+

data/lib/mapi/convert/contact.rb

@@ -0,0 +1,142 @@
+require 'rubygems'
+require 'vpim/vcard'
+
+# patch Vpim. TODO - fix upstream, or verify old behaviour was ok
+def Vpim.encode_text v
+	# think the regexp was wrong
+	v.to_str.gsub(/(.)/m) do
+		case $1
+		when "\n"
+			"\\n"
+		when "\\", ",", ";"
+			"\\#{$1}"
+		else
+			$1
+		end
+	end
+end
+
+module Mapi
+	class Message
+		class VcardConverter
+			include Vpim
+
+			# a very incomplete mapping, but its a start...
+			# can't find where to set a lot of stuff, like zipcode, jobtitle etc
+			VCARD_MAP = {
+				# these are all standard mapi properties
+				:name => [
+					{
+						:given		=> :given_name,
+						:family		=> :surname,
+						:fullname	=> :subject
+					}
+				],
+				# outlook seems to eschew the mapi properties this time,
+				# like postal_address, street_address, home_address_city
+				# so we use the named properties
+				:addr => [
+					{
+						:location	=> 'work',
+						:street		=> :business_address_street,
+						:locality	=> proc do |props|
+							[props.business_address_city, props.business_address_state].compact * ', '
+						end
+					}
+				],
+
+				# right type? maybe date
+				:birthday	=> :birthday,
+				:nickname	=> :nickname
+
+				# photo available?
+				# FIXME finish, emails, telephones etc
+			}
+
+			attr_reader :msg
+			def initialize msg
+				@msg = msg
+			end
+
+			def field name, *args
+				DirectoryInfo::Field.create name, Vpim.encode_text_list(args)
+			end
+
+			def get_property key
+				if String === key
+					return key
+				elsif key.respond_to? :call
+					value = key.call msg.props
+				else
+					value = msg.props[key]
+				end
+				if String === value and value.empty?
+					nil
+				else
+					value
+				end
+			end
+
+			def get_properties hash
+				constants = {}
+				others = {}
+				hash.each do |to, from|
+					if String === from
+						constants[to] = from
+					else
+						value = get_property from
+						others[to] = value if value
+					end
+				end
+				return nil if others.empty?
+				others.merge constants
+			end
+
+			def convert
+				Vpim::Vcard::Maker.make2 do |m|
+					# handle name
+					[:name, :addr].each do |type|
+						VCARD_MAP[type].each do |hash|
+							next unless props = get_properties(hash)
+							m.send "add_#{type}" do |n|
+								props.each { |key, value| n.send "#{key}=", value }
+							end
+						end
+					end
+
+					(VCARD_MAP.keys - [:name, :addr]).each do |key|
+						value = get_property VCARD_MAP[key]
+						m.send "#{key}=", value if value
+					end
+
+					# the rest of the stuff is custom
+
+					url = get_property(:webpage) || get_property(:business_home_page)
+					m.add_field field('URL', url) if url
+					m.add_field field('X-EVOLUTION-FILE-AS', get_property(:file_under)) if get_property(:file_under)
+
+					addr = get_property(:email_email_address) || get_property(:email_original_display_name)
+					if addr
+						m.add_email addr do |e|
+							e.format ='x400' unless msg.props.email_addr_type == 'SMTP'
+						end
+					end
+
+					if org = get_property(:company_name)
+						m.add_field field('ORG', get_property(:company_name))
+					end
+
+					# TODO: imaddress
+				end
+			end
+		end
+
+		def to_vcard
+			#p props.raw.reject { |key, value| key.guid.inspect !~ /00062004-0000-0000-c000-000000000046/ }.
+			#	map { |key, value| [key.to_sym, value] }.reject { |a, b| b.respond_to? :read }
+			#y props.to_h.reject { |a, b| b.respond_to? :read }
+			VcardConverter.new(self).convert
+		end
+	end
+end
+

data/lib/mapi/convert/note-mime.rb

@@ -0,0 +1,274 @@
+require 'base64'
+require 'mime'
+require 'time'
+
+# there is still some Msg specific stuff in here.
+
+module Mapi
+	class Message
+		def mime
+			return @mime if @mime
+			# if these headers exist at all, they can be helpful. we may however get a
+			# application/ms-tnef mime root, which means there will be little other than
+			# headers. we may get nothing.
+			# and other times, when received from external, we get the full cigar, boundaries
+			# etc and all.
+			# sometimes its multipart, with no boundaries. that throws an error. so we'll be more
+			# forgiving here
+			@mime = Mime.new props.transport_message_headers.to_s, true
+			populate_headers
+			@mime
+		end
+
+		def headers
+			mime.headers
+		end
+
+		# copy data from msg properties storage to standard mime. headers
+		# i've now seen it where the existing headers had heaps on stuff, and the msg#props had
+		# practically nothing. think it was because it was a tnef - msg conversion done by exchange.
+		def populate_headers
+			# construct a From value
+			# should this kind of thing only be done when headers don't exist already? maybe not. if its
+			# sent, then modified and saved, the headers could be wrong?
+			# hmmm. i just had an example where a mail is sent, from an internal user, but it has transport
+			# headers, i think because one recipient was external. the only place the senders email address
+			# exists is in the transport headers. so its maybe not good to overwrite from.
+			# recipients however usually have smtp address available.
+			# maybe we'll do it for all addresses that are smtp? (is that equivalent to 
+			# sender_email_address !~ /^\//
+			name, email = props.sender_name, props.sender_email_address
+			if props.sender_addrtype == 'SMTP'
+				headers['From'] = if name and email and name != email
+					[%{"#{name}" <#{email}>}]
+				else
+					[email || name]
+				end
+			elsif !headers.has_key?('From')
+				# some messages were never sent, so that sender stuff isn't filled out. need to find another
+				# way to get something
+				# what about marking whether we thing the email was sent or not? or draft?
+				# for partition into an eventual Inbox, Sent, Draft mbox set?
+				# i've now seen cases where this stuff is missing, but exists in transport message headers,
+				# so maybe i should inhibit this in that case.
+				if email
+					# disabling this warning for now
+					#Log.warn "* no smtp sender email address available (only X.400). creating fake one"
+					# this is crap. though i've specially picked the logic so that it generates the correct
+					# email addresses in my case (for my organisation).
+					# this user stuff will give valid email i think, based on alias.
+					user = name ? name.sub(/(.*), (.*)/, "\\2.\\1") : email[/\w+$/].downcase
+					domain = (email[%r{^/O=([^/]+)}i, 1].downcase + '.com' rescue email)
+					headers['From'] = [name ? %{"#{name}" <#{user}@#{domain}>} : "<#{user}@#{domain}>" ]
+				elsif name
+					# we only have a name? thats screwed up.
+					# disabling this warning for now
+					#Log.warn "* no smtp sender email address available (only name). creating fake one"
+					headers['From'] = [%{"#{name}"}]
+				else
+					# disabling this warning for now
+					#Log.warn "* no sender email address available at all. FIXME"
+				end
+			# else we leave the transport message header version
+			end
+
+			# for all of this stuff, i'm assigning in utf8 strings.
+			# thats ok i suppose, maybe i can say its the job of the mime class to handle that.
+			# but a lot of the headers are overloaded in different ways. plain string, many strings
+			# other stuff. what happens to a person who has a " in their name etc etc. encoded words
+			# i suppose. but that then happens before assignment. and can't be automatically undone
+			# until the header is decomposed into recipients.
+			recips_by_type = recipients.group_by { |r| r.type }
+			# i want to the the types in a specific order.
+			[:to, :cc, :bcc].each do |type|
+				# don't know why i bother, but if we can, we try to sort recipients by the numerical part
+				# of the ole name, or just leave it if we can't
+				recips = recips_by_type[type]
+				recips = (recips.sort_by { |r| r.obj.name[/\d{8}$/].hex } rescue recips)
+				# switched to using , for separation, not ;. see issue #4
+				# recips.empty? is strange. i wouldn't have thought it possible, but it was right?
+				headers[type.to_s.sub(/^(.)/) { $1.upcase }] = [recips.join(', ')] unless recips.empty?
+			end
+			headers['Subject'] = [props.subject] if props.subject
+
+			# fill in a date value. by default, we won't mess with existing value hear
+			if !headers.has_key?('Date')
+				# we want to get a received date, as i understand it.
+				# use this preference order, or pull the most recent?
+				keys = %w[message_delivery_time client_submit_time last_modification_time creation_time]
+				time = keys.each { |key| break time if time = props.send(key) }
+				time = nil unless Date === time
+
+				# now convert and store
+				# this is a little funky. not sure about time zone stuff either?
+				# actually seems ok. maybe its always UTC and interpreted anyway. or can be timezoneless.
+				# i have no timezone info anyway.
+				# in gmail, i see stuff like 15 Jan 2007 00:48:19 -0000, and it displays as 11:48.
+				# can also add .localtime here if desired. but that feels wrong.
+				headers['Date'] = [Time.iso8601(time.to_s).rfc2822] if time
+			end
+
+			# some very simplistic mapping between internet message headers and the
+			# mapi properties
+			# any of these could be causing duplicates due to case issues. the hack in #to_mime
+			# just stops re-duplication at that point. need to move some smarts into the mime
+			# code to handle it.
+			mapi_header_map = [
+				[:internet_message_id, 'Message-ID'],
+				[:in_reply_to_id, 'In-Reply-To'],
+				# don't set these values if they're equal to the defaults anyway
+				[:importance, 'Importance', proc { |val| val.to_s == '1' ? nil : val }],
+				[:priority, 'Priority', proc { |val| val.to_s == '1' ? nil : val }],
+				[:sensitivity, 'Sensitivity', proc { |val| val.to_s == '0' ? nil : val }],
+				# yeah?
+				[:conversation_topic, 'Thread-Topic'],
+				# not sure of the distinction here
+				# :originator_delivery_report_requested ??
+				[:read_receipt_requested, 'Disposition-Notification-To', proc { |val| from }]
+			]
+			mapi_header_map.each do |mapi, mime, *f|
+				next unless q = val = props.send(mapi) or headers.has_key?(mime)
+				next if f[0] and !(val = f[0].call(val))
+				headers[mime] = [val.to_s]
+			end
+		end
+
+		# redundant?
+		def type
+			props.message_class[/IPM\.(.*)/, 1].downcase rescue nil
+		end
+
+		# shortcuts to some things from the headers
+		%w[From To Cc Bcc Subject].each do |key|
+			define_method(key.downcase) { headers[key].join(' ') if headers.has_key?(key) }
+		end
+
+		def body_to_mime
+			# to create the body
+			# should have some options about serializing rtf. and possibly options to check the rtf
+			# for rtf2html conversion, stripping those html tags or other similar stuff. maybe want to
+			# ignore it in the cases where it is generated from incoming html. but keep it if it was the
+			# source for html and plaintext.
+			if props.body_rtf or props.body_html
+				# should plain come first?
+				mime = Mime.new "Content-Type: multipart/alternative\r\n\r\n"
+				# its actually possible for plain body to be empty, but the others not.
+				# if i can get an html version, then maybe a callout to lynx can be made...
+				mime.parts << Mime.new("Content-Type: text/plain\r\n\r\n" + props.body) if props.body
+				# this may be automatically unwrapped from the rtf if the rtf includes the html
+				mime.parts << Mime.new("Content-Type: text/html\r\n\r\n"  + props.body_html) if props.body_html
+				# temporarily disabled the rtf. its just showing up as an attachment anyway.
+				#mime.parts << Mime.new("Content-Type: text/rtf\r\n\r\n"   + props.body_rtf)  if props.body_rtf
+				# its thus currently possible to get no body at all if the only body is rtf. that is not
+				# really acceptable FIXME
+				mime
+			else
+				# check no header case. content type? etc?. not sure if my Mime class will accept
+				Log.debug "taking that other path"
+				# body can be nil, hence the to_s
+				Mime.new "Content-Type: text/plain\r\n\r\n" + props.body.to_s
+			end
+		end
+
+		def to_mime
+			# intended to be used for IPM.note, which is the email type. can use it for others if desired,
+			# YMMV
+			Log.warn "to_mime used on a #{props.message_class}" unless props.message_class == 'IPM.Note'
+			# we always have a body
+			mime = body = body_to_mime
+
+			# If we have attachments, we take the current mime root (body), and make it the first child
+			# of a new tree that will contain body and attachments.
+			unless attachments.empty?
+				mime = Mime.new "Content-Type: multipart/mixed\r\n\r\n"
+				mime.parts << body
+				# i don't know any better way to do this. need multipart/related for inline images
+				# referenced by cid: urls to work, but don't want to use it otherwise...
+				related = false
+				attachments.each do |attach|
+					part = attach.to_mime
+					related = true if part.headers.has_key?('Content-ID') or part.headers.has_key?('Content-Location')
+					mime.parts << part
+				end
+				mime.headers['Content-Type'] = ['multipart/related'] if related
+			end
+
+			# at this point, mime is either
+			# - a single text/plain, consisting of the body ('taking that other path' above. rare)
+			# - a multipart/alternative, consiting of a few bodies (plain and html body. common)
+			# - a multipart/mixed, consisting of 1 of the above 2 types of bodies, and attachments.
+			# we add this standard preamble if its multipart
+			# FIXME preamble.replace, and body.replace both suck.
+			# preamble= is doable. body= wasn't being done because body will get rewritten from parts
+			# if multipart, and is only there readonly. can do that, or do a reparse...
+			# The way i do this means that only the first preamble will say it, not preambles of nested
+			# multipart chunks.
+			mime.preamble.replace "This is a multi-part message in MIME format.\r\n" if mime.multipart?
+
+			# now that we have a root, we can mix in all our headers
+			headers.each do |key, vals|
+				# don't overwrite the content-type, encoding style stuff
+				next if mime.headers.has_key? key
+				# some new temporary hacks
+				next if key =~ /content-type/i and vals[0] =~ /base64/
+				next if mime.headers.keys.map(&:downcase).include? key.downcase
+				mime.headers[key] += vals
+			end
+			# just a stupid hack to make the content-type header last, when using OrderedHash
+			mime.headers['Content-Type'] = mime.headers.delete 'Content-Type'
+
+			mime
+		end
+	end
+
+	class Attachment
+		def to_mime
+			# TODO: smarter mime typing.
+			mimetype = props.attach_mime_tag || 'application/octet-stream'
+			mime = Mime.new "Content-Type: #{mimetype}\r\n\r\n"
+			mime.headers['Content-Disposition'] = [%{attachment; filename="#{filename}"}]
+			mime.headers['Content-Transfer-Encoding'] = ['base64']
+			mime.headers['Content-Location'] = [props.attach_content_location] if props.attach_content_location
+			mime.headers['Content-ID'] = [props.attach_content_id] if props.attach_content_id
+			# data.to_s for now. data was nil for some reason.
+			# perhaps it was a data object not correctly handled?
+			# hmmm, have to use read here. that assumes that the data isa stream.
+			# but if the attachment data is a string, then it won't work. possible?
+			data_str = if @embedded_msg
+				mime.headers['Content-Type'] = 'message/rfc822'
+				# lets try making it not base64 for now
+				mime.headers.delete 'Content-Transfer-Encoding'
+				# not filename. rather name, or something else right?
+				# maybe it should be inline?? i forget attach_method / access meaning
+				mime.headers['Content-Disposition'] = [%{attachment; filename="#{@embedded_msg.subject}"}]
+				@embedded_msg.to_mime.to_s
+			elsif @embedded_ole
+				# kind of hacky
+				io = StringIO.new
+				Ole::Storage.new io do |ole|
+					ole.root.type = :dir
+					Ole::Storage::Dirent.copy @embedded_ole, ole.root
+				end
+				io.string
+			else
+				# FIXME: shouldn't be required
+				data.read.to_s rescue ''
+			end
+			mime.body.replace @embedded_msg ? data_str : Base64.encode64(data_str).gsub(/\n/, "\r\n")
+			mime
+		end
+	end
+
+	class Msg < Message
+		def populate_headers
+			super
+			if !headers.has_key?('Date')
+				# can employ other methods for getting a time. heres one in a similar vein to msgconvert.pl,
+				# ie taking the time from an ole object
+				time = @root.ole.dirents.map { |dirent| dirent.modify_time || dirent.create_time }.compact.sort.last
+				headers['Date'] = [Time.iso8601(time.to_s).rfc2822] if time
+			end
+		end
+	end
+end
+