Class: Mapi::Pst::Item

Inherits:
Message show all
Includes:
RecursivelyEnumerable
Defined in:
lib/mapi/pst.rb

Defined Under Namespace

Classes: EntryID

Constant Summary

Constants inherited from Message

Message::CONVERSION_MAP

Instance Attribute Summary collapse

Attributes inherited from Item

#properties

Instance Method Summary collapse

Methods inherited from Message

#body_to_mime, #body_to_tmail, #convert, #headers, #mime, #mime_type, #populate_headers, #to_mime, #to_post, #to_tmail, #to_vcard

Constructor Details

#initialize(node, list, type = nil) ⇒ Item

Returns a new instance of Item.

Parameters:

  • node (NodePtr)
  • list (Array)
  • type (Object, nil) (defaults to: nil) 


1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
 
# File 'lib/mapi/pst.rb', line 1686

def initialize node, list, type=nil
	@node = node
	super Pst.make_property_set(list)

	# this is kind of weird, but the ids of the special folders are stored in a hash
	# when the root item is loaded
	if ipm_wastebasket_entryid
		node.pst.special_folder_ids[ipm_wastebasket_entryid] = :wastebasket
	end

	if finder_entryid
		node.pst.special_folder_ids[finder_entryid] = :finder
	end

	# and then here, those are used, along with a crappy heuristic to determine if we are an
	# item
=begin
i think the low bits of the desc_id can give some info on the type.

it seems that 0x4 is for regular messages (and maybe contacts etc)
0x2 is for folders, and 0x8 is for special things like rules etc, that aren't visible.
=end
	unless type
		type = props.valid_folder_mask || ipm_subtree_entryid || props.content_count || props.subfolders ? :folder : :message
		if type == :folder
			type = node.pst.special_folder_ids[node.node_id] || type
		end
	end

	@type = type
end

Instance Attribute Details

#parent ⇒ Item

Returns:



1681
1682
1683
 
# File 'lib/mapi/pst.rb', line 1681

def parent
  @parent
end

#type ⇒ Symbol

Obtain item type

  • ‘:folder`

  • ‘:message`

  • ‘:wastebasket`

Returns:

  • (Symbol) 


1678
1679
1680
 
# File 'lib/mapi/pst.rb', line 1678

def type
  @type
end

Instance Method Details

#attachments ⇒ Array<Attachment>

Returns:



1811
1812
1813
 
# File 'lib/mapi/pst.rb', line 1811

def attachments
	@attachments ||= AttachmentTable.new(@node).to_a.map { |list| Attachment.new list }
end

#children ⇒ Array<Item>

Enumerate direct children

Returns:



1761
1762
1763
 
# File 'lib/mapi/pst.rb', line 1761

def children
	to_enum(:each_child).to_a
end

#each_child {|item| ... } ⇒ void

This method returns an undefined value.

Yields:

  • (item)

Yield Parameters:



1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
 
# File 'lib/mapi/pst.rb', line 1721

def each_child
	id = ipm_subtree_entryid
	if id
		root = @node.pst.node_from_id id
		raise "couldn't find root" unless root
		raise 'both kinds of children' unless @node.children.empty?
		children = root.children
		# lets look up the other ids we have.
		# typically the wastebasket one "deleted items" is in the children already, but
		# the search folder isn't.
		extras = [ipm_wastebasket_entryid, finder_entryid].compact.map do |id|
			root = @node.pst.node_from_id id
			warn "couldn't find root for id #{id}" unless root
			root
		end.compact
		# i do this instead of union, so as not to mess with the order of the
		# existing children.
		children += (extras - children)
		children
	else
		@node.children
	end.each do |node|
		item = @node.pst.pst_parse_item(node)
		item.parent = self
		yield item
	end
end

#each_recursive {|item| ... } ⇒ void

This method returns an undefined value.

Iterate children (except on this instance) recursively stored in this MessageStore.

Yields:

  • (item)

Yield Parameters:



1826
1827
1828
1829
1830
1831
1832
1833
 
# File 'lib/mapi/pst.rb', line 1826

def each_recursive(&block)
	#p :self => self
	children.each do |child|
		#p :child => child
		block[child]
		child.each_recursive(&block)
	end
end

#finder_entryid ⇒ Object

Search Root Record



1784
1785
1786
 
# File 'lib/mapi/pst.rb', line 1784

def finder_entryid
	@finder_entryid ||= EntryID.new(props.finder_entryid.read).id rescue nil
end

#inspect ⇒ Object 



1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
 
# File 'lib/mapi/pst.rb', line 1835

def inspect
	attrs = %w[display_name subject sender_name subfolders]
#			attrs = %w[display_name valid_folder_mask ipm_wastebasket_entryid finder_entryid content_count subfolders]
	str = attrs.map { |a| b = props.send a; " #{a}=#{b.inspect}" if b }.compact * ','

	type_s = type == :message ? 'Message' : type == :folder ? 'Folder' : type.to_s.capitalize + 'Folder'
	str2 = 'node_id=0x%x' % @node.node_id

	!str.empty? ? "#<Pst::#{type_s} #{str2}#{str}>" : "#<Pst::#{type_s} #{str2} props=#{props.inspect}>" #\n" + props.transport_message_headers + ">"
end

#ipm_subtree_entryid ⇒ Object

Top of Personal Folder Record



1770
1771
1772
 
# File 'lib/mapi/pst.rb', line 1770

def ipm_subtree_entryid
	@ipm_subtree_entryid ||= EntryID.new(props.ipm_subtree_entryid.read).id rescue nil
end

#ipm_wastebasket_entryid ⇒ Object

Deleted Items Folder Record



1777
1778
1779
 
# File 'lib/mapi/pst.rb', line 1777

def ipm_wastebasket_entryid
	@ipm_wastebasket_entryid ||= EntryID.new(props.ipm_wastebasket_entryid.read).id rescue nil
end

#path ⇒ String

Returns:

  • (String) 


1750
1751
1752
1753
1754
1755
1756
 
# File 'lib/mapi/pst.rb', line 1750

def path
	parents, item = [], self
	parents.unshift item while item = item.parent
	# remove root
	parents.shift
	parents.map { |item| item.props.display_name or raise 'unable to construct path' } * '/'
end

#recipients ⇒ Array<Recipient>

Returns:



1816
1817
1818
1819
 
# File 'lib/mapi/pst.rb', line 1816

def recipients
	#[]
	@recipients ||= RecipientTable.new(@node).to_a.map { |list| Recipient.new list }
end