lambder-rexchange 0.4.0

data/CHANGELOG

@@ -0,0 +1,52 @@
+-- 0.3.4:
+* Updated the README so it jives with the current version
+* Removed Folder::join since it's only used by Folder#to_s, and just used a simpler
+	solution in Folder#to_s instead
+
+-- 0.3.3:
+* Folder objects now default to using the Message class for enumeration 
+  if no class is associated with the content_type of the Folder.
+  
+-- 0.3.2:
+* Quick hack to make Message#move_to work
+
+-- 0.3.1:
+* Disabled a warning about overwriting GenericItem::CONTENT_CLASS
+* Added a "rescue" for Time::parse failures that reverts to the original element text
+
+-- 0.3.0:
+* Added support for Appointments
+* Options hash for Session creation is gone. The new form is: "RExchange::Session.new(url, username, password)"
+* Removed GenericItem#[], GenericItem#method_missing (attributes are explicit now)
+* Removed Folder#get_messages, #get_contacts and #messages_in. Folders are now Enumerables using Enumerable#entries, #each, etc
+  to retrieve entries according to the folder's content-class. So a 'mailfolder' will retrieve Message instances,
+  a 'calendarfolder' will retrieve Appointment instances, and so on.
+
+-- 0.2.0:
+* Fixed a bug in Message#move_to when passing folders
+* Added support for Contact browsing
+* Added GenericItem to abstract Contacts and Messages
+* Renamed Folder#messages to Folder#get_messages to avoid naming collisions
+* Modified attributes in GenericItem that end with "date" to be Time::parse'd
+* Added "r_exchange.rb" for Rails auto-require compatibility
+* Now calling String#normalize on attribute names instead of just String#tr('-', '_')
+
+-- 0.1.4:
+* Moved Folder::normalize_folder_name to String#normalize, and added support for MixedCase sources.
+* Fixed a bug where the normalized folder name was being used for the Folder#to_s result.
+* Moved the meat of Folder#messages to Message::find
+* Added Message#to_s
+* Modified Folder#get_folders to return a hash instead of an array, providing both the original, and normalized names.
+
+-- 0.1.3: Bugfixes
+* Fixed several nasty bugs.
+
+-- 0.1.2: Minor documentation/cleanup
+* Removed a double-dash in the README that was apparently causing some viewing errors
+* Changed Session initialize to a ternary condition
+* Added RExchange::Message#has_attachments?
+* Added documentation for most methods in RExchange::Message and RExchange::Folder
+
+-- 0.1.1
+* Fleshed out the README
+* Copied the RAKEFILE from the Rools project

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2006 Samuel Smoot
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/RAKEFILE

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'pscp'
+
+PACKAGE_VERSION = '0.3.4'
+
+PACKAGE_FILES = FileList[
+  'README',
+  'CHANGELOG',
+  'RAKEFILE',
+  'MIT-LICENSE',
+  'lib/**/*.rb',
+  'test/*.rb'
+].to_a
+
+PROJECT = 'rexchange'
+
+ENV['RUBYFORGE_USER'] = "ssmoot@rubyforge.org"
+ENV['RUBYFORGE_PROJECT'] = "/var/www/gforge-projects/#{PROJECT}"
+
+task :default => [:rdoc]
+
+desc 'Generate Documentation'
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "RExchange -- A simple wrapper around Microsoft Exchange Server's WebDAV API"
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include(PACKAGE_FILES)
+end
+
+gem_spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PROJECT
+  s.summary = "A simple wrapper around Microsoft Exchange Server's WebDAV API"
+  s.description = "Connect, browse, and iterate through folders and messages on an Exchange Server"
+  s.version = PACKAGE_VERSION
+  
+  s.authors = 'Sam Smoot', 'Scott Bauer'
+  s.email = 'ssmoot@gmail.com; bauer.mail@gmail.com'
+  s.rubyforge_project = PROJECT
+  s.homepage = 'http://substantiality.net'
+  
+  s.files = PACKAGE_FILES
+  
+  s.require_path = 'lib'
+  s.requirements << 'none'
+  s.autorequire = 'rexchange'
+  
+  s.has_rdoc = true
+  s.rdoc_options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+end
+
+Rake::GemPackageTask.new(gem_spec) do |p|
+  p.gem_spec = gem_spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc "Publish RDOC to RubyForge"
+task :rubyforge => [:rdoc, :gem] do
+  Rake::SshDirPublisher.new(ENV['RUBYFORGE_USER'], ENV['RUBYFORGE_PROJECT'], 'doc').upload
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*.rb']
+  t.verbose = true
+end

data/README

@@ -0,0 +1,86 @@
+= RExchange
+
+RExchange is a pure ruby wrapper for the Microsoft Exchange Server WebDAV API
+
+== Things you should know
+
+* Requires Ruby 1.8.4 (or later, for the extended WebDAV support in the net/http library)
+* RExchange is cross-platform compatible, being written in pure Ruby
+* Kiwi fruits are packed with vitamins
+
+== Why should you use RExchange
+
+* It makes interacting with Exchange simple
+* It was written for a real application, and does real work reliably day in and day out
+
+== Example
+
+	# We pass our uri (pointing directly to a mailbox), a username, and a password to RExchange::open
+	# to create a RExchange::Session. Notice that we escape the "\" in our username.
+	RExchange::open('https://example.com/exchange/admin/', 'mydomain\\admin', 'secret') do |mailbox|
+  
+		# The block parameter ("mailbox" in this case) is actually the Session itself.
+		# You can refer to folders by chaining them as method calls. "inbox" in this case
+		# isn't a defined method for Session, but part of the DSL to refer to folder names.
+		# Each folder name returns a RExchange::Folder. The folder is Enumerable, allowing
+		# iteration over the items in the folder, depending on the DAV:content-class of
+		# the folder.
+		mailbox.inbox.each do |message|
+    
+			# The "message" block parameter is a RExchange::Message object. You have access to
+			# several attributes of the message, including: href, from, to, message_id, date,
+			# importance, has_attachment? and body.
+			p message.subject
+    
+			# The RExchange::Message#move_to method moves the message to another folder, in this
+			# case, an "archive" folder off of the inbox.
+			message.move_to mailbox.inbox.archive
+		end
+  
+		# Folder names are "normalized", replacing dashes and spaces with underscores,
+		# squeezing out multiple underscores in a row, and downcasing the whole thing.
+		# So a folder name such as "My Very-long Folder Name" would look like:
+		mailbox.my_very_long_folder_name
+  
+		# The Enumerable mixin gives us an Folder#entries method in case we just want to
+		# return an array.
+		messages = mailbox.inbox.entries
+	
+		# Other methods, like Enumerable#map and Enumerable#sort_by let us manipulate
+		# the Folder in fun ways:
+		puts mailbox.contacts.sort_by { |contact| contact.first_name }.map do |contact|
+			<<-CONTACT
+				Name:    #{contact.first_name} #{contact.last_name}
+				Email:   #{contact.email}
+				Phone:   #{contact.phone}
+			CONTACT
+		end
+	
+	end
+
+	# We can access the Global Address Book by accessing the "/public" folder:
+	RExchange::open('https://example.com/public', 'mydomain\\somebody', 'secret') do |mailbox|
+
+		puts mailbox.company_contacts.each do |contact|
+			<<-CONTACT
+				Company: #{contact.company}
+				Name:    #{contact.first_name} #{contact.last_name}
+				Email:   #{contact.email}
+				Phone:   #{contact.phone}
+			CONTACT
+	 end
+
+	end
+	
+== Caveats
+
+There are several features missing (simply because we didn't need them yet). Among them:
+
+* The ability to delete messages or folders
+* The ability to create folders
+* There's no mechanism for sending new messages, or replying or forwarding existing ones
+* There are a lot more message attributes we're not retrieving since they weren't useful to us, but they might be to you
+* Exporting an email or entire folder tree to offline storage
+* And much much more!
+
+If you'd like to see any of these features, or have some ideas of your own you'd like to see implemented don't hesitate to let us know, and if it strikes our fancy maybe you'll get some free programming!

data/lib/r_exchange.rb

@@ -0,0 +1,2 @@
+# Provided for compatibility with RubyOnRails auto-require functionality.
+require 'rexchange'

data/lib/rexchange.rb

@@ -0,0 +1,33 @@
+require 'rexchange/session'
+require 'rexchange/r_exception'
+
+class String
+  def ends_with?(partial)
+    self[self.size - partial.size..self.size] == partial
+  end
+
+  def ensure_ends_with(partial)
+    self.ends_with?(partial) ? self : self + partial
+  end
+
+  def normalize
+    self.split(/(?=[A-Z][a-z]*)/).join('_').tr('- ', '_').squeeze('_').downcase
+  end
+end
+
+module RExchange
+  # Use STDOUT or another stream if you'd like to capture the HTTP debug output
+  DEBUG_STREAM = $log
+
+  PR_HTTPMAIL_READ = 'read'
+  NS_HTTPMAIL = 'urn:schemas:httpmail'
+
+  # A shortcut to RExchange::Session#new
+  def self.open(dav_uri, owa_uri, username = nil, password = nil)
+    session = RExchange::Session.new(dav_uri, owa_uri, username, password)
+
+    yield session if block_given?
+    return session
+  end
+
+end

data/lib/rexchange/appointment.rb

@@ -0,0 +1,38 @@
+require 'rexchange/generic_item'
+
+module RExchange
+  class Appointment < GenericItem
+    
+    set_folder_type 'calendar'
+    
+    attribute_mappings :all_day_event => 'urn:schemas:calendar:alldayevent',
+      :busy_status => 'urn:schemas:calendar:busystatus',
+      :contact => 'urn:schemas:calendar:contact',
+      :contact_url => 'urn:schemas:calendar:contacturl',
+      :created_on => 'urn:schemas:calendar:created',
+      :description_url => 'urn:schemas:calendar:descriptionurl',
+      :end_at => 'urn:schemas:calendar:dtend',
+      :created_at => 'urn:schemas:calendar:dtstamp',
+      :start_at => 'urn:schemas:calendar:dtstart',
+      :duration => 'urn:schemas:calendar:duration',
+      :expires_on => 'urn:schemas:calendar:exdate',
+      :expiry_rule => 'urn:schemas:calendar:exrule',          
+      :has_attachment? => 'urn:schemas:httpmail:hasattachment', 
+      :html => 'urn:schemas:httpmail:htmldescription', 
+      :modified_on => 'urn:schemas:calendar:lastmodified', 
+      :location => 'urn:schemas:calendar:location', 
+      :location_url => 'urn:schemas:calendar:locationurl', 
+      :meeting_status => 'urn:schemas:calendar:meetingstatus', 
+      :normalized_subject => 'urn:schemas:httpmail:normalizedsubject', 
+      :priority => 'urn:schemas:httpmail:priority', 
+      :recurres_on => 'urn:schemas:calendar:rdate', 
+      :reminder_offset => 'urn:schemas:calendar:reminderoffset', 
+      :reply_time => 'urn:schemas:calendar:replytime', 
+      :sequence => 'urn:schemas:calendar:sequence', 
+      :subject => 'urn:schemas:httpmail:subject', 
+      :body => 'urn:schemas:httpmail:textdescription', 
+      :timezone => 'urn:schemas:calendar:timezone', 
+      :uid => 'urn:schemas:calendar:uid'
+
+  end
+end  

data/lib/rexchange/contact.rb

@@ -0,0 +1,29 @@
+require 'rexchange/generic_item'
+
+module RExchange
+  class Contact < GenericItem
+    
+    set_folder_type 'contact'
+    set_content_class 'person'
+
+    attribute_mappings :first_name => 'urn:schemas:contacts:givenName',
+      :middle_name => 'urn:schemas:contacts:middlename',
+      :last_name => 'urn:schemas:contacts:sn',
+      :title => 'urn:schemas:contacts:title',
+      :created_at => 'DAV:creationdate',
+      :address => 'urn:schemas:contacts:mailingstreet',
+      :city => 'urn:schemas:contacts:mailingcity',
+      :state => 'urn:schemas:contacts:st',
+      :zip_code => 'urn:schemas:contacts:mailingpostalcode',
+      :country => 'urn:schemas:contacts:co',
+      :phone => 'urn:schemas:contacts:homePhone',
+      :business_phone => 'urn:schemas:contacts:telephoneNumber',
+      :fax => 'urn:schemas:contacts:facsimiletelephonenumber',
+      :mobile => 'urn:schemas:contacts:mobile',    
+      :email => 'urn:schemas:contacts:email1',
+      :website => 'urn:schemas:contacts:businesshomepage',
+      :company => 'urn:schemas:contacts:o',
+      :notes => 'urn:schemas:httpmail:textdescription'
+
+  end  
+end

data/lib/rexchange/credentials.rb

@@ -0,0 +1,38 @@
+require 'uri'
+
+module RExchange
+
+  # Credentials are passed around between Folders to emulate a stateful
+  # connection with the RExchange::Session
+  class Credentials
+    attr_reader :user, :password, :dav_uri, :owa_uri
+    attr_accessor :auth_cookie
+
+    # You must pass a dav_uri, owa_uri, a username and a password
+    def initialize(dav_uri = nil, owa_uri = nil, username = nil, password = nil)
+      owa_uri = nil if owa_uri && owa_uri.blank?
+      @dav_uri = URI.parse(dav_uri) if dav_uri
+      @owa_uri = URI.parse(owa_uri) if owa_uri
+      @dav_use_ssl = @dav_uri.scheme ? (@dav_uri.scheme.downcase == 'https') : false
+      @user = username || (@dav_uri && @dav_uri.userinfo ? @dav_uri.userinfo.split(':')[0] : nil) || (@owa_uri && @owa_uri.userinfo ? @owa_uri.userinfo.split(':')[0] : nil)
+      @password = password || (@dav_uri && @dav_uri.userinfo ? @dav_uri.userinfo.split(':')[1] : nil) || (@owa_uri && @owa_uri.userinfo ? @owa_uri.userinfo.split(':')[1] : nil)
+      @dav_port = (@dav_uri.port || @dav_uri.default_port) if @dav_uri
+      @owa_port = (@owa_uri.port || @owa_uri.default_port) if @owa_uri
+      if block_given?
+        yield self
+      else
+        return self
+      end
+    end
+    
+    def dav_use_ssl?
+      @dav_use_ssl
+    end
+
+    def is_owa?
+      @owa_uri && @owa_uri.scheme && @owa_uri.host
+    end
+    
+  end
+  
+end

data/lib/rexchange/dav_get_request.rb

@@ -0,0 +1,28 @@
+require 'rexchange/exchange_request'
+
+module RExchange
+  # Used for arbitrary SEARCH requests
+  class DavGetRequest < ExchangeRequest
+    METHOD = 'GET'
+    REQUEST_HAS_BODY = false
+    RESPONSE_HAS_BODY = true
+
+    def self.execute(credentials, url, &b)
+      begin
+        options = {
+                :path => url,
+                :headers => {
+                        'Translate' => 'f'   # Microsoft IIS 5.0 "Translate: f" Source Disclosure Vulnerability (http://www.securityfocus.com/bid/1578)
+                }
+        }
+        response = super credentials, options
+        yield response if b
+        response
+      rescue RException => e
+        raise e
+      rescue Exception => e
+        raise RException.new(options[:request], response, e)
+      end
+    end
+  end
+end

data/lib/rexchange/dav_move_request.rb

@@ -0,0 +1,30 @@
+require 'rexchange/exchange_request'
+
+module RExchange
+  # Used to move entities to different locations in the accessable mailbox.
+  class DavMoveRequest < ExchangeRequest
+    METHOD = 'MOVE'
+    REQUEST_HAS_BODY = false
+    RESPONSE_HAS_BODY = false
+
+    def self.execute(credentials, source, destination, &b)
+      begin
+        options = {
+                :headers => {
+                        'Destination' => destination
+                },
+                :path => source
+        }
+
+        response = super credentials, options
+        yield response if b
+        response
+      rescue RException => e
+        raise e
+      rescue Exception => e
+        raise RException.new(options[:request], response, e)
+      end
+    end
+  end
+
+end

data/lib/rexchange/dav_search_request.rb

@@ -0,0 +1,8 @@
+require 'rexchange/exchange_request'
+
+module RExchange
+  # Used for arbitrary SEARCH requests
+  class DavSearchRequest < ExchangeRequest
+    METHOD = 'SEARCH'
+  end
+end

data/lib/rexchange/exchange_request.rb

@@ -0,0 +1,86 @@
+require 'net/https'
+
+module RExchange
+
+  # Exchange Server's WebDAV interface is non-standard, so
+  # we create this simple wrapper to extend the 'net/http'
+  # library and add the request methods we need.
+  class ExchangeRequest < Net::HTTPRequest
+    REQUEST_HAS_BODY = true
+    RESPONSE_HAS_BODY = true
+
+    def self.authenticate(credentials)
+      owa_uri = credentials.owa_uri
+      if owa_uri
+        http = Net::HTTP.new(owa_uri.host, owa_uri.port)
+        http.set_debug_output(RExchange::DEBUG_STREAM) if RExchange::DEBUG_STREAM
+        req = Net::HTTP::Post.new(owa_uri.path)
+        destination = owa_uri.scheme+"://"+owa_uri.host+(owa_uri.port ? ':'+owa_uri.port.to_s : '')
+        req.body = "destination=#{destination}&username=#{credentials.user}&password=#{credentials.password}"
+        http.use_ssl = owa_uri.scheme ? (owa_uri.scheme.downcase == 'https') : false
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        res = http.request(req)
+        credentials.auth_cookie = res.header["set-cookie"].split(',').map(&:strip).map{|c| c.split(';')[0]}.reverse.join('; ') if res.header["set-cookie"]
+      end
+    end
+
+    def self.exchange_request(credentials, options = {})
+      http = Net::HTTP.new(credentials.dav_uri.host, credentials.dav_uri.port)
+      http.set_debug_output(RExchange::DEBUG_STREAM) if RExchange::DEBUG_STREAM
+      request_path = options[:path] || credentials.dav_uri.path
+      req = self.new(request_path)
+      options[:request] = req
+      req.basic_auth credentials.user, credentials.password #if !credentials.is_owa?
+      req.content_type = 'text/xml'
+      req.add_field 'host', credentials.dav_uri.host
+
+      if options[:headers]
+        options[:headers].each_pair do |k, v|
+          req.add_field k, v
+        end
+      end
+
+      req.body = options[:body] if REQUEST_HAS_BODY
+      http.use_ssl = credentials.dav_use_ssl?
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      response = http.request(req) if RESPONSE_HAS_BODY
+
+    end
+
+    def self.execute(credentials, options = {}, &b)
+      begin
+        headers = options[:headers] ||= {}
+        headers['Cookie'] = credentials.auth_cookie if credentials.auth_cookie
+        response = self.exchange_request(credentials, options)
+        case response
+        when Net::HTTPClientError then
+          self.authenticate(credentials)
+          #repeat exchange_request after authentication with the auth-cookies
+          headers = options[:headers] ||= {}
+          headers['Cookie'] = credentials.auth_cookie if credentials.auth_cookie
+          response = self.exchange_request(credentials, options)
+        end
+
+        raise 'NOT 2xx NOR 3xx: ' + response.inspect.to_s unless (Net::HTTPSuccess === response || Net::HTTPRedirection === response)
+        
+        yield response if b
+        response
+      rescue RException => e
+        raise e
+      rescue Exception => e
+        #puts e.backtrace.map{|e| e.to_s}.join("\n")
+        raise RException.new(options[:request], response, e)
+      end
+
+    end
+
+    private
+    # You can not instantiate an ExchangeRequest externally.
+    def initialize(*args)
+      super
+    end
+  end
+end
+
+
+

data/lib/rexchange/folder.rb

@@ -0,0 +1,102 @@
+require 'rexml/document'
+require 'net/https'
+require 'rexchange/dav_search_request'
+require 'rexchange/message'
+require 'rexchange/contact'
+require 'rexchange/appointment'
+require 'rexchange/note'
+require 'rexchange/task'
+require 'rexchange/message_href'
+require 'uri'
+
+module RExchange
+
+  class FolderNotFoundError < StandardError
+  end
+
+  class Folder
+    include REXML
+
+    attr_reader :credentials, :displayname
+
+    def initialize(credentials, parent, displayname, href, content_type)
+      @credentials, @parent, @href = credentials, parent, href
+      @content_type = CONTENT_TYPES[content_type] || Message
+      @displayname = displayname
+    end
+
+    # Used to access subfolders.
+    def method_missing(sym, *args)
+
+      if folders_hash.has_key?(sym.to_s)
+        folders_hash[sym.to_s]
+      else
+        puts folders_hash.keys.inspect
+        puts sym.to_s
+        raise FolderNotFoundError.new("#{sym} is not a subfolder of #{@displayname} - #{@href}")
+      end
+    end
+
+    include Enumerable
+
+    def message_hrefs(href_regex)
+      RExchange::MessageHref::find_message_hrefs(href_regex, @credentials, to_s)
+    end
+
+    # Iterate through each entry in this folder
+    def each
+      @content_type::find(@credentials, to_s).each do |item|
+        yield item
+      end
+    end
+
+    # Not Implemented!
+    def search(conditions = {})
+      raise NotImplementedError.new('Bad Touch!')
+      @content_type::find(@credentials, to_s, conditions)
+    end
+
+    # Return an Array of subfolders for this folder
+    def folders
+      @folders ||=
+              begin
+                request_body = <<-eos
+  				<D:searchrequest xmlns:D = "DAV:">
+  					 <D:sql>
+  					 SELECT "DAV:displayname", "DAV:contentclass"
+  					 FROM SCOPE('shallow traversal of "#{@href}"')
+  					 WHERE "DAV:ishidden" = false
+                         AND "DAV:isfolder" = true
+  					 </D:sql>
+  				</D:searchrequest>
+                eos
+                folders = []
+                DavSearchRequest.execute(@credentials, :body => request_body) do |response|
+
+
+                  # iterate through folders query and add a new Folder
+                  # object for each, under a normalized name.
+                  xpath_query = "/*/a:response[a:propstat/a:status/text() = 'HTTP/1.1 200 OK']"
+                  Document.new(response.body).elements.each(xpath_query) do |m|
+                    href = m.elements['a:href'].text
+                    displayname = m.elements['a:propstat/a:prop/a:displayname'].text
+                    contentclass = m.elements['a:propstat/a:prop/a:contentclass'].text
+                    folders << Folder.new(@credentials, self, displayname, href, contentclass.split(':').last.sub(/folder$/, ''))
+                  end
+
+                end
+                folders
+              end
+
+    end
+
+    def folders_hash
+      @folders_hash ||= folders.inject({}){|memo, f| memo[f.displayname.normalize]=f; memo}
+    end
+
+    # Return the absolute path to this folder (but not the full URI)
+    def to_s
+      @href
+    end
+  end
+end

data/lib/rexchange/generic_item.rb

@@ -0,0 +1,124 @@
+require 'rexml/document'
+require 'ostruct'
+require 'rexchange/dav_move_request'
+require 'rexchange/dav_get_request'
+require 'time'
+
+module RExchange
+
+  class Folder
+    CONTENT_TYPES = {}
+  end
+
+  class GenericItem
+    include REXML
+    include Enumerable
+
+    attr_accessor :attributes
+
+    def initialize(session, dav_property_node)
+      @attributes = {}
+      @session = session
+
+      dav_property_node.elements.each do |element|
+        namespaced_name = element.namespace + element.name
+
+        if element.name =~ /date$/i || self.class::ATTRIBUTE_MAPPINGS.find { |k, v| v == namespaced_name && k.to_s =~ /\_(at|on)$/ }
+          @attributes[namespaced_name] = Time::parse(element.text) rescue element.text
+        else
+          @attributes[namespaced_name] = element.text
+        end
+      end
+    end
+
+    # Set the default CONTENT_CLASS to the class name, and define a
+    # dynamic query method for the derived class.
+    def self.inherited(base)
+      base.const_set('CONTENT_CLASS', base.to_s.split('::').last.downcase)
+
+      def base.query(path)
+        <<-QBODY
+          SELECT
+            #{self::ATTRIBUTE_MAPPINGS.values.map { |f| '"' + f + '"' }.join(',')}
+          FROM SCOPE('shallow traversal of "#{path}"')
+          WHERE "DAV:ishidden" = false
+            AND "DAV:isfolder" = false
+            AND "DAV:contentclass" = 'urn:content-classes:#{self::CONTENT_CLASS}'
+        QBODY
+      end
+    end
+
+    # This handy method is meant to be called from any inheriting
+    # classes. It is used to bind types of folders to particular
+    # Entity classes so that the folder knows what type it's
+    # enumerating. So for a "calendarfolder" you'd call:
+    #   set_folder_type 'calendarfolder' # or just 'calendar'
+    def self.set_folder_type(dav_name)
+      Folder::CONTENT_TYPES[dav_name.sub(/folder$/, '')] = self
+    end
+
+    # --Normally Not Used--
+    # By default the CONTENT_CLASS is determined by the name
+    # of your class. So for the Appointment class the
+    # CONTENT_CLASS would be 'appointment'.
+    # If for some reason this convention doesn't suit you,
+    # you can use this method to set the appropriate value
+    # (which is used in queries).
+    # For example, the DAV:content-class for contacts is:
+    #   'urn:content-classes:person'
+    # Person doesn't strike me as the best name for our class though.
+    # Most people would refer to an entry in a Contacts folder as
+    # a Contact. So that's what we call our class, and we use this method
+    # to make sure everything still works as it should.
+    def self.set_content_class(dav_name)
+      verbosity, $VERBOSE = $VERBOSE, nil # disable warnings for the next operation
+      const_set('CONTENT_CLASS', dav_name)
+      $VERBOSE = verbosity # revert to the original verbosity
+    end
+
+    # Defines what attributes are used in queries, and
+    # what methods they map to in instances. You should
+    # pass a Hash of method_name symbols and namespaced-attribute-name pairs.
+    def self.attribute_mappings(mappings)
+
+      mappings.merge! :uid => 'DAV:uid',
+              :modified_at => 'DAV:getlastmodified',
+              :href => 'DAV:href'
+
+      const_set('ATTRIBUTE_MAPPINGS', mappings)
+
+      mappings.each_pair do |k, v|
+
+        define_method(k) do
+          @attributes[v]
+        end
+
+        define_method("#{k.to_s.sub(/\?$/, '')}=") do |value|
+          @attributes[v] = value
+        end
+
+      end
+    end
+
+    # Retrieve an Array of items (such as Contact, Message, etc)
+    def self.find(credentials, path, conditions = nil)
+      qbody = <<-QBODY
+  			<D:searchrequest xmlns:D = "DAV:">
+  				 <D:sql>
+           #{conditions.nil? ? query(path) : search(path, conditions)}
+           </D:sql>
+        </D:searchrequest>
+      QBODY
+      items = []
+      DavSearchRequest.execute(credentials, :body => qbody) do |response|
+
+        xpath_query = "//a:propstat[a:status/text() = 'HTTP/1.1 200 OK']/a:prop"
+
+        Document.new(response.body).elements.each(xpath_query) do |m|
+          items << self.new(credentials, m)
+        end
+      end
+      items
+    end
+  end
+end

data/lib/rexchange/message.rb

@@ -0,0 +1,88 @@
+require 'rexchange/generic_item'
+require 'rexchange/dav_proppatch_request'
+
+module RExchange
+  class Message < GenericItem
+
+    set_folder_type 'mail'
+
+    attribute_mappings :from => 'urn:schemas:httpmail:from',
+            :to => 'urn:schemas:httpmail:to',
+            :message_id => 'urn:schemas:mailheader:message-id',
+            :subject => 'urn:schemas:httpmail:subject',
+            :recieved_on => 'urn:schemas:httpmail:date',
+            :importance => 'urn:schemas:httpmail:importance',
+            :has_attachments? => 'urn:schemas:httpmail:hasattachment',
+            :body => 'urn:schemas:httpmail:textdescription',
+            :html => 'urn:schemas:httpmail:htmldescription'
+
+
+    # Move this message to the specified folder.
+    # The folder can be a string such as 'inbox/archive' or a RExchange::Folder.
+    # === Example
+    #   mailbox.inbox.each do |message|
+    #     message.move_to mailbox.inbox.archive
+    #   end
+    def move_to(folder)
+      destination =
+              if folder.is_a?(RExchange::Folder)
+                folder.to_s.ensure_ends_with('/') + self.href.split('/').last
+              else
+                @session.uri.path.ensure_ends_with('/') + folder.to_s.ensure_ends_with('/') + self.href.split('/').last
+              end
+
+      DavMoveRequest.execute(@session, self.href, destination)
+    end
+
+    # Delete this message.
+    # === Example
+    #   mailbox.inbox.each do |message|
+    #     message.delete!
+    #   end
+    def delete!
+      response = DavDeleteRequest.execute(@session, self.href)
+      case response.code
+      when 204 then
+        # Standard success response.   ( http://msdn.microsoft.com/en-us/library/aa142839(EXCHG.65).aspx )
+        true
+      when 423 then
+        # The destination resource is locked.
+        false
+      end
+    end
+
+
+    def to_s
+      "To: #{to}, From: #{from}, Subject: #{subject}"
+    end
+
+    def raw
+      fetch(href, limit = 10)
+    end
+
+    def fetch(uri_str, limit = 10)
+      # You should choose better exception.
+      raise ArgumentError, 'HTTP redirect too deep' if limit == 0
+      response = DavGetRequest.execute(@session, uri_str)
+      case response
+      when Net::HTTPSuccess     then
+        response.body
+      when Net::HTTPRedirection then
+        fetch(response['location'], limit - 1)
+      else
+        response.error!
+      end
+    end
+
+    def mark_as_read
+      response = DavProppatchRequest.execute(@session, self.href, RExchange::PR_HTTPMAIL_READ, RExchange::NS_HTTPMAIL, 1)
+      case response
+      when Net::HTTPSuccess then
+        true
+      else
+        false
+      end
+    end
+
+  end
+end

data/lib/rexchange/note.rb

@@ -0,0 +1,16 @@
+require 'rexchange/generic_item'
+
+module RExchange
+  class Note < GenericItem
+    
+    set_folder_type 'note'
+   
+    attribute_mappings :displayname => 'DAV:displayname',
+      :created_at => 'DAV:creationdate', 
+      :subject =>'urn:schemas:httpmail:subject',
+      :body => 'urn:schemas:httpmail:textdescription'
+      
+     end  
+  
+  
+   end

data/lib/rexchange/session.rb

@@ -0,0 +1,28 @@
+require 'uri'
+require 'rexchange/folder'
+require 'rexchange/credentials'
+
+module RExchange 
+
+  class Session < Folder
+    
+    # Creates a Credentials instance to pass to subfolders
+    # === Example
+    #   RExchange::Session.new('https://mydomain.com/exchange/demo', 'https://mydomain.com/owa/auth/owaauth.dll', 'mydomain\\bob', 'secret') do |mailbox|
+    #     mailbox.test.each do |message|
+    #       puts message.subject
+    #     end
+    #   end
+    def initialize(dav_uri, owa_uri, username = nil, password = nil)
+    
+      @credentials = Credentials.new(dav_uri, owa_uri, username, password)
+      @parent = @credentials.dav_uri.path
+      @folder = ''
+      @href = @credentials.dav_uri.to_s
+      
+      yield(self) if block_given?
+    end
+      
+  end 
+
+end

data/lib/rexchange/task.rb

@@ -0,0 +1,26 @@
+require 'rexchange/generic_item'
+
+module RExchange
+  class Task < GenericItem
+    
+    set_folder_type 'task'
+   
+    attribute_mappings :displayname => 'DAV:displayname',
+      :created_at => 'DAV:creationdate', 
+      :subject =>'urn:schemas:httpmail:subject',
+      :body => 'urn:schemas:httpmail:textdescription',
+      :percent_complete =>'http://schemas.microsoft.com/exchange/tasks/percentcomplete',
+      :owner =>'http://schemas.microsoft.com/exchange/tasks/owner',
+      :is_complete =>'http://schemas.microsoft.com/exchange/tasks/is_complete',
+      :date_start =>'http://schemas.microsoft.com/exchange/tasks/dtstart',
+      :date_due =>'http://schemas.microsoft.com/exchange/tasks/dtdue',
+      :actual_effort =>'http://schemas.microsoft.com/exchange/tasks/actualeffort', 
+      :estimated_effort =>'http://schemas.microsoft.com/exchange/tasks/estimatedeffort',
+      :priority =>'http://schemas.microsoft.com/mapi/priority',
+      :status =>'http://schemas.microsoft.com/exchange/tasks/status',
+      :state =>'http://schemas.microsoft.com/exchange/tasks/state'
+      
+     end  
+  
+  
+   end

data/test/functional.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'rexchange'
+
+class FunctionalTests < Test::Unit::TestCase
+  
+  def setup
+    @mailbox = RExchange::Session.new 'url', 'username', 'password'
+  end
+  
+  def teardown
+    @mailbox = nil
+  end
+  
+  # Ok, so it's not a real test, but I needed to get started,
+  # and get rid of console scripts.
+  def test_no_exceptions
+
+    @mailbox.inbox.search(:from => 'scott').each do |m|
+      puts m.subject
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: lambder-rexchange
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Sam Smoot
+- Scott Bauer
+- Daniel Kwiecinski
+autorequire: rexchange
+bindir: bin
+cert_chain: []
+
+date: 2009-08-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Connect, browse, and iterate through folders and messages on an Exchange Server
+email: ssmoot@gmail.com; bauer.mail@gmail.com; daniel@lambder.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- RAKEFILE
+- MIT-LICENSE
+files: 
+- README
+- CHANGELOG
+- RAKEFILE
+- MIT-LICENSE
+- lib/r_exchange.rb
+- lib/rexchange/appointment.rb
+- lib/rexchange/contact.rb
+- lib/rexchange/credentials.rb
+- lib/rexchange/dav_get_request.rb
+- lib/rexchange/dav_move_request.rb
+- lib/rexchange/dav_search_request.rb
+- lib/rexchange/exchange_request.rb
+- lib/rexchange/folder.rb
+- lib/rexchange/generic_item.rb
+- lib/rexchange/message.rb
+- lib/rexchange/note.rb
+- lib/rexchange/session.rb
+- lib/rexchange/task.rb
+- lib/rexchange.rb
+- test/functional.rb
+has_rdoc: true
+homepage: http://substantiality.net
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- none
+rubyforge_project: rexchange
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A simple wrapper around Microsoft Exchange Server's WebDAV API (that works with Exchange 2007 using basic authentication and the form-based one.
+test_files: []
+