12/29/2007

Version 4.5.0.812

New features:

• Exposed Incremental Change Synchronization (ICS) API for the Exchange folders. ICS API allows to perform synchronization of any Exchange folder without using events (which are unreliable and can be dropped under heavy loads) or looping through all items in a folder (which is very inefficient). This is the same API used for synchronization by the cached Exchange store provider in Outlook. See RDOFolderSynchronizer object (returned by RDOFolder2.ExchangeSynchronizer) for more information and examples.
  

  set Session = CreateObject("Redemption.RDOSession") Session.Logon 'set Folder = Session.GetDefaultFolder(olFolderInbox) ' first synchronization set Synchonizer = Folder.ExchangeSynchonizer 'no data at first run, this really needs to come from some persistent storage saved after the previous sync ' (see the last line in the sample), otherwise all items in the folder will be returned strPreviousSyncData = "" set SyncItems = Synchonizer.SyncItems(strPreviousSyncData) 'first run will report all items in the folder as modified since strPreviousSyncData is empty if SyncItems.Count = 0 Then     Debug.Print "There were no changes in the folder" Else     Debug.Print "There were " & SyncItems.Count & " changes in the folder. The list of changes follows:"     for each Item in SyncItems         if Item.Kind = 0 Then 'sikChanged             'modification             Debug.Print "Modified: " & Item.Item.Subject         Elseif Item.Kind = 1 Then 'sikDeleted             'deletion. Since the item is gone, RDOSyncMessageItem.Item will be NULL             Debug.Print "Deletion. Source key = " & Item.SourceKey         Elseif Item.Kind = 2 Then 'sikReadStatusChanged             'read/unread state changed             Debug.Print "Read/unread state changed: " & Item.Item.Subject         End If    next EndIf '  IMPORTANT: remember/store the sync cookie to be used next time when calling SyncItems (see above) strPreviousSyncData = SyncItems.SyncData




• Exchange Server in the online mode limits the number of simultaneously open MAPI objects (see KB 830829) and returns MAPI_E_CALL_FAILED when attempting to open more objects.
  Since .Net does not release COM objects immediately (resulting in Redemption objects holding a reference to the underlying MAPI objects), it is easy to run over the limit, sometimes even if Marshal.ReleaseCOMObject() or GC.Collect() are used to explicitly release Redemption (and hence MAPI) objects, especially if multiple dot notation is used (resulting in implicit variables created by the compiler). This problem manifests itself most frequently when looping through a large number of messages in a folder.
  This version of Redemption keeps track of the open MAPI objects and transparently releases the objects that can easily be reopened on demand (only oldest unmodified or saved objects are automatically released). This is done transparently, no change to the existing code is required. Note that only the internally used MAPI objects are automatically released and reopened (if necessary), Redemption objects stay alive.
  Messages (RDOMail), attachments (RDOAttachment), folders (RDOFolder), folder content tables (RDOItems), hierarchy tables (RDOFolders), attachment tables (RDOAttachments)  and ACLs (RDOACL) are tracked for automatic release.





• Added RDOSession.LogonPstStore method that, in addition to the Logon and LogonExchangeMailbox methods and setting the MAPIOBJECT property, allows to log to MAPI.
  LogonPstStore, similar to the LogonExchangeMailbox method, creates a temporary profile, adds the specified PST store (new or existing) to that temporary profile, and log to the profile. The temporary profile is immediately deleted, so it will never be visible to an end user.
  LogonPstStore is useful if you need to process a PST file without explicitly creating a new profile using ProfMan and/or without adding the temporary PST store to an existing profile using RDOSession.Stores.AddPstStore:
  

  'create initialize first RDOSession object that shared the MAPI session with Outlook set Session = CreateObject("Redemption.RDOSession") Session.MAPIOBJECT = Application.Session.MAPIOBJECT 'create and initialize a temporary session that uses a new or existing PST file set TempSession = CreateObject("Redemption.RDOSession") TempSession.LogonPstStore "c:\temp\archive_test.pst", 1, "Archive PST Store" 'delete all folders in the temporary PST store to make sure there is no collision set ArchiveRootFolder = TempSession.Stores.DefaultStore.IPMRootFolder set SubFolders = ArchiveRootFolder.Folders for i = SubFolders.Count to 1 step - 1     SubFolders.Remove(i) next 'copy the contents of the default store used by the first session 'to the PST file used by the second session for each Folder in Session.Stores.DefaultStore.IPMRootFolder.Folders     Folder.CopyTo(ArchiveRootFolder) next




• Added support for the field aliases (AS operator) in the SQL expressions in MAPITable.ExecSQL, RDOItems.Find/Restrict methods. Useful to keep SQL queries readable as well as if the recordset returned by ExecSQL is used by other routines that expect recordsets with predefined field names.
  

  'Aliases. Select all messages replied to '0x10810003 will be referred to as PR_LAST_VERB_EXECUTED 'EntryID will be aliased as ID set Table = CreateObject("Redemption.MAPITable") Table.Item = Application.ActiveExplorer.CurrentFolder.Items set Recordset = Table.ExecSQL("SELECT Subject, EntryID AS ID, ""http://schemas.microsoft.com/mapi/proptag/0x10810003"" AS PR_LAST_VERB_EXECUTED FROM Folder " & _                                                    "WHERE PR_LAST_VERB_EXECUTED = 102 or PR_LAST_VERB_EXECUTED = 103 " & _                                                    "ORDER BY LastModificationTime DESC") while not Recordset.EOF     Debug.Print(Recordset.Fields("Subject").Value & " - " & Recordset.Fields("ID").Value)     Recordset.MoveNext wend




• Added RDOPOP3Account.DeliverToStore / DeliverToFolder / SaveSentMessageFolder properties (Outlook 2007 specific)





• You can now specify folder fields (visible in the Field Picker for a given folder and accessible through the RDOFolder2.FolderFields collection) in a SQL query (MAPITable.ExecSQL and RDOItems.Find/Restrict). Custom property names can be specified either in the DASL format (e.g. "http://schemas.microsoft.com/mapi/string/{00020329-0000-0000-C000-000000000046}/PropertyName") or simply as the property name (e.g. "PropertyName"). The previous version of Redemption always assumed a string property type (since the property type cannot be specified in the "string" DASL namespace) for such properties.
  
  

• Calendar Access Control rights (Exchange): added RDOACE.FreeBusySimple and RDOACE.FreeBusyDetailed properties (Outlook 2007 / Exchange 2007 specific)





• MAPITable.ExecSQL performance was significantly improved for the queries with no restriction (no WHERE clause).





• Redemption now supports Exchange 2007 without Public Folders (standalone MAPI download only). You will need to set a special registry key to force Redemption to use the CONNECT_IGNORE_NO_PF flag when calling RDOSession.LogonExchangeMailbox. Note: Redemption does not use CDO 1.21 (which Outlook 2007 does not even install) in any way, it just can reuse the same registry key that Microsoft documented for use with CDO 1.21.





• RDOAddressEntry object: added NTAccountName, NTAccountSid, Alias (Exchange specific), AssistantName, BusinessTelephoneNumber, City, Comments, CompanyName, Department, FirstName, JobTitle, LastName, MobileTelephoneNumber, OfficeLocation, PostalCode, StateOrProvince, StreetAddress properties.





• Redemption will automatically set the value of the RDOMail.InternetCodePage property (unless it was explicitly programmatically set) whenever a string property (Subject, Body, etc) is set to a Unicode string with the code page different from the current user code page.





• Added MAPITable.CreateBookmark, FreeBookmark, GoToBookmark, GoToNext, GoToPrevious methods.





• Improved performance of the RDOMail.CopyTo method. The performance of the  RDOMail.SaveAs(..., olMsg) and RDOMail.Import(..., olMsg) methods was also improved as the result of this change.





• Improved performance of the RDOFolder.CopyTo method for the Exchange folders residing in different stores (e.g. 2 Exchange mailboxes, or an Exchange mailbox folder and an Public Folders folder).





• RDOAttachments.Add can now take another RDOAttachment object (all attachment properties are copied) or a variant array of bytes (assumed to be the raw attachment data) besides a string (file name) or another message (RDOMail) in the Source argument.
  
  

• Added SafeInspector.RtfEditor.SelAttributes.BackColor property that allows to retrieve and set the background text color.
  
  

• Added RDOSession.CreateMessageFromMsgFile method which returns a new message (RDOMail or one of the derived types, such as RDOContactItem) created on top of a new MSG file.
  Unlike RDOSession.GetMessageFromMsgFile (which can also create a new MSG file), you can specify the MSG file format (default, Unicode, ANSI) and the message class of the new item so you will always get back the right item kind rather than the generic RDOMail.
  

  'Create a contact (can be any other type of item) on top of a new MSG file 'Below we will get back a contact since we explicitly specify the message class ("IPM.Contact"). 'The MSG file will be created in the Unicode format for Outlook 2003 or higher or ANSI format 'for the older versions of Outlook (since mffDefault = 1 is used) 'The last two parameters are optional set Session = CreateObject("Redemption.RDOSession") Session.Logon    'don't really need to call this method set Contact = Session.CreateMessageFromMsgFile("c:\temp\TestContact.Msg", "IPM.Contact", 1) Contact.FirstName = "Dmitry" Contact.LastName = "Streblechenko" Contact.EMail1Address = "redemption@dimastr.com" Contact.Save

Bug fixes:

• Specifying the Sent, Submitted, Unread properties in the WHERE clause in MAPITable.ExecSQL, RDOItems.Find/Restrict methods (e.g. "SELECT Subject from folder where Unread = 'true' ") produced as error "Unexpected constant used with Sent/Submitted/Unread: 'TRUE' ". Note that you could still use 1 or 0 (no quotes) instead of "true" or "false", e.g. SELECT Subject from folder where Unread = 1 ".
• MAPITable.ExecSQL did not always insert list separator between entries for the multi-valued string properties (such as Categories or Companies) in the returned recordset.
• Creating a Redemption object on a machine with no MAPI system installed (no Outlook, Exchange Server/Admin or standalone version of MAPI) produced a message box with an error description blocking the application execution instead of raising a (trappable) error.
• Specifying Start, End and Duration properties in a SQL queries in MAPITable.ExecSQL, RDOItems.Find/Restrict and RDOFolderSearchCriteria.AsSQL resulted in an "unknown property name" error if the folder container class property (PR_CONTAINER_CLASS) was anything but "IPF.Appointment" or "IPF.Journal".
• Messages restored using RDODeletedItems.Restore were always created in the unsent state.
• Accessing RDOMail.Body from a secondary thread with no Windows message pump hanged if the message did not contain the RTF body (PR_RTF_COMPRESSED) but contained the HTML body (PR_HTML).
• RDODistListItem.Members collection returned wrong RDOAddressEntry objects for the entries corresponding to the Business/Home/Other fax numbers of a contact added to the distribution list.
• Specifying Subject property in a WHERE clause in the MAPITable.ExecSQL and RDOItems.Find/Restrict methods always performed the search on the PR_NORMALIZED_SUBJECT property (subject minus the prefix) even if the Subject property was explicitly specified in the DASL format (e.g. http://schemas.microsoft.com/mapi/proptag/0x0037001E).  This version will search on PR_NORMALIZED_SUBJECT if the property name is in the OOM format (Subject), but if the property name is in the DASL format, it will search on PR_SUBJECT.
• The result of setting the RDOContactItem.EmailXAddress and EmailXDisplayName properties was inconsistent with the Outlook Object Model.
• RDOAddressEntry.SmtpAddress property returned an empty string for the "MSN" type addresses.
• Under certain circumstances accessing any properties of the RDOAddressEntry object returned by the Sender/SentOnBehalfOf  properties of the RDOMail object created on top of an MSG file resulted in an error.
• RDORecurrencePattern.DayOfWeekMask property incorrectly returned 62 (weekday) instead of 65 (weekend) for the olRecursYearNth / weekend recurrence patterns.
• For the weekly recurrences, RDORecurrencePattern did not take into account locale specific first day of week and always assumed Monday as the first day of week.
• Calling RDOMail.GetIDsFromNames  or Safe*Item.GetIDsFromNames  on a read-only message (or a message created on top of a read-only MSG file) resulted in an error even if the specified named property existed.
• Reading RDOFolderSearchCriteria.AsSQL or RDORule.ConditionsAsSQL properties failed if the restriction contained a binary (PT_BINARY) property.
• Saving messages in the RTF format (RDOMail.Save(..., olRtf) and Safe*Item.SaveAs(..., olRtf)) produced incorrect headers (Subject, Sender, etc) for the Unicode values.
• RDOFolder2.GetActivitiesForTimeRange() failed to account for exceptions of recurring activities under certain circumstances.
• Setting RDONoteItem.Color property did not update the message icon.
• Saving Unicode messages in the TXT format (Safe*Item / RDOMail.SaveAs(..., olTxt) ) did not always correctly set the From header.
• RtfBody property (RDOMail.RtfBody and Safe*Item.RtfBody) included an extra NULL terminating character.
• Saving in the RTF format (Safe*Item / RDOMail.SaveAs(..., olRtf)) did not include any Contact/Appointment/Task specific properties for the messages other than the regular IPM.Note message headers.
• RTF files produced by Safe*Item / RDOMail.SaveAs(..., olRtf)) were unreadable for some RTL languages (such as Hebrew or Arabic).
• Saving messages in the RTF format (SaveAs ..., olRtf) for the messages with embedded OLE objects (such as Excel spreadsheets), sometimes produced prompts from the host app (such as Excel prompting that the object may not be safe to load).
• RDOMail and RDOFolder events fired for all messages or folders in the parent store, not just a particular message or folder.
• RDOCalendarOptions object (returned by RDOExchangeMailboxStore.CalendarOptions property) failed with the "Error in HrGetOneProp(PR_FREEBUSY_ENTRYIDS): MAPI_E_NOT_FOUND" error for the cached Exchange stores in Outlook 2003 and Outlook 2007.
• New messages returned by RDOMail.Forward / Reply/ ReplyAll did not have correct values of the Sensitivity and Importance properties set (based on the original message properties).
• Setting the RDOAppointmentItem.Start property did not always property adjust all the related recurrence (RDOAppointmentItem.GetRecurrencePattern) properties (such as RDORecurrencePattern.DayOfMonth etc)
• Setting the RDOAppointmentItem.MeetingStatus property to olMeeting did not update the ResponseStatus property.
• For the recurring activities with no end date created by RDO (RDOAppointmentItem), Outlook displayed "until 12/31/4500" in the recurrence description in the inspector.
• RDOAttachments.Add did not raise an error when adding non-existent or inaccessible files.
• Redemption returned RDOMail object rather than IRDOMeetingItem for the meeting cancelation messages (message class = "IPM.Schedule.Meeting.Canceled").
• Accessing any properties of the RDOFolder object returned by the RDOAddressList.GetContactsFolder method resulted in a MAPI_E_UNKNOWN_ENTRYID error.
• Setting the RDOExchangeMailboxStore.IsCached and RDOExchangePublicFoldersStore.IsCached properties resulted in the "Error in MAPISession.OpenProfileSection: MAPI_E_UNKNOWN_FLAGS" error. Note that reading the properties did not return any errors.
• Under certain circumstances, accessing any properties of a message returned by RDOMail.Move when the message was moved from a primary to a delegate mailbox, returned "Error in IMAPISession::OpenEntry: MAPI_E_INVALID_ENTRYID" error.
• Messages created in a delegate store (returned by RDOSession.GetSharedMailbox) were not moved to the delegate store's Sent Items folder after they were sent.

07/23/2007

Version 4.4.0.714 This version does not introduce any new functionality, but only fixes several issues introduced in the previous versions.

Bug fixes

• No IMsgStore-level events (RDOStore, RDOFolder and RDOMail events) were fired in version 4.4.0.674. RDOStores, RDOItems and RDOFolders events were Ok.

• MAPITable.ExecSQL, RDOItems.Find/Restrict methods did not handle single quotes (encoded as double quotes) under certain circumstances (e.g. " SELECT FileAs, EntryID FROM Folder WHERE LastName = 'O''Connor'  ")

• MAPITable.ExecSQL, RDOItems.Find/Restrict methods dropped some conditions for the WHERE clauses with a large number of conditions.

• MAPITable.ExecSQL, RDOItems.Find/Restrict methods returned no results if the WHERE clause contained a condition specifying an empty string (e.g. Subject = '' ).

• MAPITable.ExecSQL, RDOItems.Find/Restrict methods returned no results if the WHERE clause contained a condition specifying a named MAPI property in the DASL format in the "string" namespace (e.g. "http://schemas.microsoft.com/mapi/string/{00020329-0000-0000-C000-000000000046}/test") .

• MAPITable.ExecSQL, RDOItems.Find/Restrict methods did not handle Currency (PT_CURRENCY) properties in the WHERE clause.

• MAPITable.ExecSQL returned binary (PT_BINARY) properties as variant arrays for the properties specified in the DASL format and as strings (hex) for the OOM properties (e.g. EntryID). New version will always return binary properties as hex strings.

• MAPITable.ExecSQL truncated large string properties at 255 characters even if the underlying store provider returned more data. Note that this version will still be subject to the property truncation if the truncation is performed by the store provider (such as Exchange store).

• Specifying binary properties (PT_BINARY, e.g. EntryID or ConversationIndex) properties in the WHERE clause in the MAPITable.ExecSQL, RDOItems.Find/Restrict methods did not return any results.

• RDORecurrencePattern.DayOfWeekMask property did not work for the daily (RecurrenceType = olRecursDaily) recurrences patterns (every day vs every work day daily patterns).

• Setting the RDORecurrencePattern.StartTime property sometimes resulted in Outlook displaying the first occurrence on a wrong date.

• RDORecurrencePattern.DayOfMonth did not work correctly for some yearly (RecurrenceType = olRecursYearly) recurrences patterns.

• RDOFolder2.GetActivitiesForTimeRange() and RDORecurrencePattern.GetOccurence failed for some yearly recurring appointments with DayOfMonth = 29, 30, 31.

• Dev version under Vista (but not the distributable version) displayed the End User License Agreement (EULA) dialog every time Redemption was loaded. Note that the distributable version was not affected since it never displays any dialogs.

• Setting the RDOMail.HTMLBody property (as well as calling RDOMail.Reply/ReplyAll/Forward) resulted in a corrupted message body if the HTML data contained certain <STYLE> tags.

• Calling RDOMail.Delete for a message created on top of an MSG file sometimes resulted in an error.

• Saving messages in the HTML format (SaveAs(..., olHTML)) did not encode the "<" and ">" characters in the message header (To/CC/Subject) and body (for the plain text messages).

• RDOMail.CopyTo/Move raised an RPC_E_FAULT error if RDOSession.MAPIOBJECT was set (rather than RDOSession.Logon/LogonExchangeMailbox called) and the calling code was running in a process space other than outlook.exe (i.e. it is not a COM add-in or Outlook VBA code).

• ProfMan.dll can now be installed on Vista even when User Access Control (UAC) is enabled and/or the current user does not have write access to the HKLM registry hive.

06/17/2007

Version 4.4.0.674

New features

• Added RDOJournalItem object (corresponds to the JournalItem object in the Outlook Object Model).

• Added RDOItems.Find/FindNext/Restrict methods that allow to find items using a standard SQL style string. Specifying a SELECT clause allows Redemption to pre-fetch specified properties directly from the folder contents table without opening the MAPI messages later resulting in a significant performance gain.
  

  set Session = CreateObject("Redemption.RDOSession") Session.Logon set Contacts = Session.GetDefaultFolder(olFolderContacts) set Items = Contacts.Items set Contact = Items.Find("SELECT Email1Address, FileAs from Folder where LastName = 'Streblechenko' ORDER BY FirstName") while Not (Contact Is Nothing)     'access properties specified in the SELECT clause above     'accessing other properties will force Redemption to open the corresponding MAPI object, try to avoid that if possible     Debug.Print Contact.FileAs & ": " & Contact.Email1Address     set Contact = Items.FindNext wend

• Added RDOItems.Sort method.

• Added MAPITable.ExecSQL method that allows to specify the properties to retrieve, restriction conditions and the sort order as a standard SQL string with the property names either in the DASL or OOM format. The method returns an instance of the standard ADODB.Recordset object populated with data:
  

  set Session = CreateObject("Redemption.RDOSession") Session.Logon set Folder = Session.GetDefaultFolder(olFolderInbox) set Items = Folder.Items set Table = Items.MAPITable Set Recordset = Table.ExecSQL("SELECT Subject, ReceivedTime, EntryID from Folder " & _                                                    "where Unread ='true' " & _                                                    "order by ReceivedTime desc") while not Recordset.EOF     Debug.Print(Recordset.Fields("ReceivedTime").Value & " - " & Recordset.Fields("Subject").Value)     Recordset.MoveNext wend

• Added RDOFolderSearchCriteria.AsSQL property that allows to set and retrieve the search criteria as a SQL string.

• MAPITable.Columns can now also be set to a variant array containing DASL or OOM property names (string, such as "urn:schemas:httpmail:subject" or "Subject") or a comma separated string (e.g. "Subject, SenderName") rather than a variant array of integer property tags (see example below). Note that it still always returns a variant array of integer tags.

• MAPITable.Sort method now allows to pass the columns as a comma separated string (e.g. "Subject, SenderName") rather than as a variant array of integer property tags - see example below.

• Added RDOFolder2.GetActivitiesForTimeRange method that allows to retrieve a sorted list of activities in a given time range with the instances of recurring appointments appropriately expanded:

  set Session = CreateObject("Redemption.RDOSession") Session.Logon set Folder = Session.GetDefaultFolder(olFolderCalendar) set Items = Folder.GetActivitiesForTimeRange(#6/1/2007#, #7/1/2007#, true) for each item in items     Debug.Print item.Start & " " & item.Subject next

• The performance of the RDOItems collection was significantly increased if the collection's columns are preset by setting the RDOItems.MAPITable.Columns property and only properties specified in the columns property are retrieved from the returned items:
  

  set Session = CreateObject("Redemption.RDOSession") Session.Logon set Folder = Session.GetDefaultFolder(olFolderInbox) set Items = Folder.Items 'let Redemption know which properties we will be requesting later Items.MAPITable.Columns = "Subject, SenderName" Items.MAPITable.Sort "ReceivedTime", false for each Item in Items   'read the properties specified in the MAPITable.Columns property above   Debug.Print Item.Subject & " - " & Item.SenderName next

• Added RDOAttachment.FileSize and Attachment.FileSize properties. Unlike the Size property (which includes the binary data plus the attachment properties, such as filename etc), FileSize returns the size of the file data only.

• Added RDORule.StopProcessingOtherRules property.

• Added RDORecipient.SendRichInfo and Recipient.SendRichInfo properties

• Added RDOAttachment.CreationTime / LastModificationTime and Attachment.CreationTime / LastModificationTime properties.

• Implemented RDORecurrencePattern.GetOccurence method and RDORecurrencePattern.Exceptions collection for the RDOAppointmentItem object (see RDOExceptions and RDOException for more help).

• Added RDOExchangeMailboxStore.GetFolderFromSourceKey and RDOExchangeMailboxStore.GetMessageFromSourceKey methods that allow to open messages and folders by the value of their PR_SOURCE_KEY property rather than the entry id.

• Added MAPIUtils.ScCreateConversationIndex method - corresponds to the ScCreateConversationIndex function in MAPI or to Session.CreateConversationIndex in CDO 1.21.

• Added RDOExchangeMailboxStore.CalendarOptions object that allows to access auto accept settings, free/busy data as a collection of discrete slots, etc. See RDOCalendarOptions object help for more details.

• Added RDOAddressEntry.FreeBusyList that allows to access free/busy data for an Exchange user as a collection of discrete slots the way the data is stored by MAPI.

• Added RDOFolder2.EmptyFolder method that allows to delete all messages and subfolders in a single call.

• Added RDOSession.ExchangeConnectionMode / ExchangeMailboxServerName / ExchangeMailboxServerVersion / OutlookVersion properties.

• Added RDORule.ConditionsAsSQL property.

Bug fixes:

• Appointment updates sent by Redemption (RDOAppointmentItem.Send and SafeApointmentItem.Send) sometimes failed to correctly update the attendee's appointment.

• RDOTaskItem.Send returned "Error in HrQueryAllRows(MAPI_TO only)" when called under online Exchange store.

• Call to RDOAppointmentItem.GetRecurrencePattern took a long time to complete for appointments with a large number of exceptions.

• RDOMail.ReplyRecipients.Add/AddEx returned null.

• Redemption.dll failed to register on Windows Vista with UAC (User Access Control) turned on.

• Redemption Type Library specified IRDOMeetingItem was derived from IDispatch rather than IRDOMail.

• ProfSect.Item in the ProfMan library failed to retrieve some Unicode properties.

• Setting RDORecipient.Name property resulted in the MAPI_E_INVALID_PARAMETER error under certain circumstances.

• Setting RDOMail.HTMLBody property resulted in garbled HTML body under Outlook 2007 / Exchange 2003 in the online mode for the HTML data with embedded HTML comments.

• ProfMan library did not handle PT_MV_STRING8 and PT_MV_UNICODE properties in the ProfSect.Item(PropTag) method.

• RDOAddressEntry.Delete failed with "This feature is not implemented yet" error.

• RDOSession.NewMail event did not fire for the sessions instantiated by calling RDOSession.LogonExchangeMailbox. Note that this event still won't fire for applications running as a service (this is a MAPI limitation).

• RDORecipients.Add/AddEx and SafeRecipients.Add/AddEx did not handle Unicode names correctly.

• Modifying any of the RDOAttachment properties required an explicit call to RDOAttachment.Save followed by a call to RDOMail.Save. Now the attachment data is automatically saved when the parent message is saved (RDOMail.Save). If a modified attachment is released before the parent message is saved, the attachment (but not the message) is saved automatically, so that when RDOMail.Save is called, the changes will be persisted.

• RDOSession.GetAddressEntryFromID and RDOSession.GetAddressListFromID returned invalid objects under certain circumstances.

• RDOMail.Reply/ReplyAll/Forward methods did not set PR_LAST_VERB_EXECUTED, PR_LAST_VERB_EXECUTION_TIME, PR_ICON_INDEX MAPI properties on the original message.

• RDOSession.GetMessageFromMsgFile(..., TRUE) will now create MSG files in the Unicode (olMsgUnicode) format if Outlook 2003 or higher is installed.

• RDOItems.ItemAdd / ItemChange events sometimes passed RDOMail object to the event handler even if a different object (but derived from RDOMail, such as RDOContactItem, RDOAppointmentItem, etc) should have been passed based on the value of the message class.

• Setting RDOAppointmentItem.AllDayEvent property to false reset the Start property to 9:00 am and the Duration property to 30 minutes.

• RDOAttachments.Item and Attachments.Item only allowed an integer index (1 through Count) as a parameter, but not an attachment file name.

• Setting RDOContactItem.Email1EntryID property did not update the EmailOriginalDisplayName MAPI property.

• RDOAppointmentItem - setting the Start and End properties (but not Duration) always created an appointment with the duration of 30 minutes and ignored changes to either Start or End properties (depending on the order in which the properties were set).

• Calling RDOMail.Move was slow if the target folder had a large number of messages. If the returned value (the newly created RDOMail object) of the Move method is ignored, the method will be executed an order of magnitude faster. It can however take a considerable amount of time when any property or method on the returned message is accessed for the every first time as Redemption needs to find the new message in the target folder.

• RDOFolder2.SetAsDefaultFolder method did not set PR_CONTAINER_CLASS property appropriately for the olFolderCalendar, olFolderContacts, olFolderJournal, olFolderNotes, olFolderTasks and olFolderDrafts folders.

• Text file created by calling RDOMail / Safe*Item.SaveAs(..., olTxt) listed hidden attachments (such as embedded HTML images). RDOAttachment.Hidden property now also checks whether it is referenced by the HTML body as an embedded image.

01/07/2007

Version 4.3.0.604

New features

• Added RDOAppointmentItem object (corresponds to the AppointmentItem object in the Outlook Object Model) and RDOMeetingItem (corresponds to the MeetingItem object in the Outlook Object Model)

• Added RDOSession.Profiles collection that allows to enumerate existing profiles for the current Windows user and retrieve or set the default profile name. See RDOProfiles help for more information.

• Added RDOSession.TimeZones collection (similar to the Application.TimeZones collection in the Outlook 2007 Object Model). Dynamic DST is fully supported. See RDOTimezones, RDOTimezone, RDOAppointmentItem.StartTimeZone and RDOAppointmentItem.EndTimeZone help for more information.

• Added RDOExchangeMailboxStore.Rules collection. Note that this collection creates rules that are not displayed by the "Rules And Alerts" dialog in Outlook and is only available for the Exchange mailboxes. See RDORules for more information.

• Added RDOFolder2.DeletedFolders collection (Exchange only) that allows to enumerate and restore deleted (but recoverable) subfolders. See RDODeletedFolders help for more information.

• Added RDOMail.Actions collection representing all the available actions for the item (corresponds to the MailItem.Actions collection in the Outlook Object Model). Since all other items (RDOContactItem, RDOTaskItem, etc) are derived from RDOMail, they will expose this property as well. See RDOActions help for more information.

• Added RDOMail.VotingOptions property (corresponds to the MailItem.VotingOptions property in the Outlook Object Model).

• Added RDOMail.MarkRead method which allows (unlike the RDOMail.UnRead property) to bypass sending a read receipt (if one is requested).

• Added RDOMail.Conflicts collection that represents the items that are in conflict with the item. Since all other items (RDOContactItem, RDOTaskItem, etc) are derived from RDOMail, they will expose this collection as well. See RDOConflicts, RDOConflict and RDOMail.Conflicts for more information.

• Added SafeAppointmentItem.SendAsICal property - determines whether the meeting requests/updates for the appointment will be sent in the iCal or TNEF format. The same property is also exposed by the new RDOAppointmentItem object.

• Added olRtfNoHeaders (1026) enum for the SaveAs method. This enum forces Redemption to save the message in the RTF format but without the headers (To/CC/Subject/etc).

• Added RDOSession.SetLocaleIDs method (similar to Session.SetLocaleIDs in CDO 1.21).

• Added RDOFolder2.FindPFFavoritesCopy method that returns the folder's counterpart added to the PF Favorites.

Bug fixes:

• RDOSession.GetMessageFromMsgFile and RDOAttachment.EmbeddedMsg always returned a generic RDOMail object even if the message class corresponded to RDOContactItem, RDOTaskItem, etc object (all derived from RDOMail).

• ProfMan: removing a property by setting it to Nothing using ProfileSection.Item(PropTag) returned an error.

• RDOMail/Safe*Item.Send did not set the appropriate tracking property (PR_REPORT_TAG) when a read receipt was requested (ReadReceiptRequested = true).

• RDOAddressBook.ResolveName did not handle Unicode names correctly.

• MessageItem.SentOn property was returned in the UTC timezone.

• RDODistListItem.AddContact method returned "Could not retrieve address or fax number" error if the specified contact resided in a message store different from the Distribution List's parent store.

• Setting the RDOMail.FlagDueBy property did not set all the reminder and flag related MAPI properties the way MailItem.FlagDueBy property in the Outlook Object Model does.

• Calling RDOStores.AddPSTStore(..., olStoreDefault) on a machine with Exchange Server raised MAPI_E_NOT_FOUND error.

• RDOMail/Safe*Item.SaveAs(..., olRtf) - saving in the RTF format omitted the message headers (To/From//Subject/etc).

• RDOSession.GetMessageFromMsgFile and MAPIUtils.GetItemFromMsgFile did not handle Unicode file names correctly.

• RDOSession.GetMessageFromMsgFile and MAPIUtils.GetItemFromMsgFile returned STG_E_ACCESSDENIED error for the MSG files marked as read-only.

• Setting RDOMail/MessageItem.HTMLBody property to a Unicode string resulted in a corrupted HTML body if the current code page was different from the code page used in the HTML data.

• SafeMailItem.Send under Outlook 2007 did not move the message to the Sent Items folder. Note that RDOMail.Send was not affected.

• RDOAttachment.SaveAsFile and Attachment.SaveAsFile were raising an error if given a true Unicode file name.

• Several Redemption methods (RDOSession.GetMessageFromMsgFile, MAPIUtils.GetItemFromMsgFile, Attachments.Add, RDOMail/Safe*Item.Import, RDOContactItem.AddPicture, etc) raised an error reporting that the file does not exist if the file's last modified date was greater than year 2108.

• Safe*Item.Recipients collection did not properly return Unicode properties under certain conditions. Note that RDOMail.Recipients was not affected.

• RDOSession.GetFolderFromPath and RDOStores.Item (if name was passed as a parameter) sometimes failed for the PF store folders.

• RDOContactItem.AddPicture/RemovePicture did not work if the contact never had a picture before.

• RDODistListItem.AddContact failed when a distribution list (e.g. RDODistListItem or Outlook.DistListItem) was passed as a parameter.

• Accessing RDOAttachment.EmbeddedMsg property for an RDOMail object created on top of an MSG file caused the MSG file to remain locked.

• Redemption.dll failed to successfully install itself in a multi user environment (such as Citrix) if the Windows user registering the dll had r/w access to the HKLM and HKCR registry hives, but the dll was previously installed by another user creating registry keys that the second user could not overwrite.

• RDOFolders.Item and RDOSession.GetFolderFromPath methods failed if a Unicode folder name was passed as an argument even if the parent store natively supported Unicode.

• RDOStores.FindExchangePublicFoldersStore and RDOStores.GetDefaultFolder(olPublicFoldersAllPublicFolders / olPublicFoldersFavorites) failed under Outlook 2007 if the primary mailbox store has never been opened in the current MAPI session.

• MessageItem.LastModificationTime property returned the value in the UTC timezone, not local.

• RDOStores.AddDelegateExchangeMailBoxStore was returning NULL instead of the added delegate mailbox store (RDOExchangeMailboxStore).

• RDOStores.AddPstStore, RDOStores.AddPstStoreWithPassword and RDOPstStore.PstPath did not handle Unicode file names correctly.

• RDOTaskItem.GetRecurrencePattern hanged on certain recurrence patterns.

• RDOPstStore.Remove failed for the IMAP4 provider stores.

• RDOAttachment.SaveAsFile and Attachment.SaveAsFile for certain corrupted attachments failed to save the attachment data, but did not raise the appropriate error.
   

08/23/2006

Version 4.2.0.562

New features

• Added RDOTaskItem object (corresponds to the TaskItem object in the Outlook Object Model).

• Added RDOTaskRequestItem object (corresponds to the TaskRequestAcceptItem, TaskRequestDeclineItem, TaskRequestUpdateItem and TaskRequestItem objects in the Outlook Object Model).

• Added RDONoteItem object (corresponds to the NoteItem object in the Outlook Object Model).

• Added RDOPostItem object (corresponds to the PostItem object in the Outlook Object Model).

• Added RDOReportItem object (corresponds to the ReportItem object in the Outlook Object Model).

• added RDOAddressBook.CreateOneOffEntryID method. This method allows to create a one-off an address book entry id given an e-mail address, display name and address type. It also allows to explicitly specify whether a message to a given address must be sent in the RTF or plain text format (see example).

• added RDOMail.Links collection. Since RDOContactItem, RDOTaskItem, RDODistListItem, RDOReportItem, RDONoteItem and RDOPostItem objects are derived from RDOMail, this change makes the new Links collection available to them too.

• added RDOStores.AddPstStoreWithPassword method that allow to open password protected PST stores.

• by popular demand - added AddressEntry.SMTPAddress property (returned by the Safe*Item objects). Note that RDOAddressEntry object already had the SMTPAddress property.

• added GetFirst, GetLast, GetNext, GetPrevious methods to the RDOACL, RDOAttachments and RDORecipients collections. Note that these methods were already implemented for the RDOItems, RDOFolders, RDOAddressLists and RDOAddressEntries collections.

• added RDOContactItem.FileUnderId property.

• added RDOExchangeMailboxStore.IsCached and OstPath properties.

• added RDOExchangePublicFoldersStore.IsCached property.

• added RDOFolder2.FolderPath and RDOSearchFolder.FolderPath properties (return full path to a given folder). The path can be used to call RDOSession.GetFolderFromPath.

• added RDOFolder2.AddToPFFavorites and RDOFolder2.RemoveFromPFFavorites methods and the RDOFolder2.IsInPFFavorites property.

• added skBCM (corresponding to the Business Contact Manager store provider)  enum to the TxStoreKind enumeration (returned by the RDOStore.Kind property).

• added RDOStoreEvents.OnMessageMovedEx, RDOStoreEvents.OnFolderMovedEx, RDOFolderEvents.OnMovedEx, RDOMailEvents.OnMovedEx event - these "Ex" events provide two additional parameters - OldParentEntryID and NewParentEntryId, corresponding to the entry ids of the old and new parent folders

• added RDOFolder2.FolderFields collection that allows to access and modify custom user fields in a folder. Corresponds to "User-defined fields in this folder" in the Field Chooser in Outlook.

• added RDOAddressEntry.GetContact method (returns RDOContactItem object).

• added RDOAddressList.GetContactsFolder method.

• New values for the rdoDefaultFolders enumeration (used in the GetDefaultFolder methods): olPublicFoldersFavorites (all versions of Outlook) and olFolderRssSubscriptions, olFolderToDo and olFolderManagedEmail (Outlook 2007 specific).

• Prior to this version, accessing object properties (PT_OBJECT) using Fields() (e.g. Safe*Item.Fields, RDOFolder.Fields) returned SafeTable object for the MAPI properties that could be opened as an IMAPITable object (e.g. PR_CONTAINER_CONTENTS, PR_ACL_TABLE, etc). Starting with this version, MAPITable object is returned. Note that the old SafeTable object exposed only one property - Count, while MAPITable provides a much richer interface, including search and restrictions.

Bug fixes:

• RDOAddressEnry.SMTPAddress property did not return the SMTP address for the Outlook Address Book (OAB) entries pointing to a GAL user (accessing GAL entries worked fine).

• RDOMail.Display(TRUE) was ignoring the MAPI_E_USER_CANCEL return code when user closed a modally displayed message without sending it. If your code uses RDOMail.Display to display a message modally, make sure your code can handle the error, which is normal and should not be treated as an error, but rather as an indication how the message window was closed.

• RDOSession.Logon in a Windows service failed with MAPI_E_INVALID_PARAMETER. Note that RDOSession.LogonExchangeMailbox was not affected.

• RDOSession.GetDefaultFolder and RDOStore.GetDefaultFolder specified wrong argument type for the FolderType parameter: it must be one of the rdoDefaultFolders enums.

• Setting RDOMail.Categories, Companies and Children properties to an empty string ("") resulted in the MAPI_E_INVALID_PARAMETER error.

• accessing any properties of a message returned by RDOMail.Move caused a MAPI_E_NOT_FOUND error to be returned.

• copying or moving messages (RDOMail.CopyTo and RDOMail.Move) between different PST stores did not preserve created/last modified properties.

• importing MSG files (RDOMail.Import and Safe*Item.Import) did not handle recipients with the Unicode display names.

• RDOStore.OnSearchComplete and RDOFolder.OnSearchComplete events were not firing.

• calling RDOStore.DefaultStore, GetDefaultFolder and FindExchangePublicFoldersStore methods restricted the number of available stores in that instance of the RDOStores collection to one.

• setting the RDOContactItem.FileAs property was not being reflected in the Outlook UI or the Outlook Object Model. Setting either of the name properties (first or last name, suffix, etc) caused the FileAs property to be reset even if it was explicitly set previously.

• RDOFolder.CopyTo could not copy across different message stores.

• RDORecipients.Remove would silently fail under certain circumstances.

• Distribution lists created by Redemption (RDODistListItem) did not have a display name in Outlook Web Access (OWA).

• RDOMail.ReplyRecipients.AddEx returned an invalid variant conversion error.

• RDOSession.GetSharedMailbox and RDOStores.GetSharedMailbox failed if a store other than an Exchange mailbox was set as the default store in the profile.

• Attachment.Type and RDOAttachment.Type properties sometimes returned a value other than olByReference (4) for the by-reference attachments.

• Attachment.SaveAsFile and RDOAttachment.SaveAsFile methods failed to save by-reference attachments.

• RDODistListItem could not remove all the members of the distribution list.

• Safe*Item/RDOMail.SaveAs(..., olRFC822) silently failed on Windows 95/98/ME.

• Calling RDOMail or Safe*Item SaveAs(..., olMsg) sometimes failed to save the message body in the MSG file.

02/27/2006

Version 4.1.0.507

• New feature: added events support for the RDOSession, RDOStore, RDOFolder, RDOMail, RDOItems, RDOFolders, RDOStores, RDOAccounts objects.
• New feature: new object - RDODistListItem, derived from the RDOMail object and corresponding to the IPM.DistList messages in Outlook. Everywhere RDOMail is normally returned (RDOSession.GetMessageFromID, RDOFolder.Items, etc), RDODistListItem will be returned if the message class is "IPM.DistList".
• New feature: new object - RDOContactItem, derived from the RDOMail object and corresponding to the IPM.Contact messages in Outlook. Everywhere RDOMail is normally returned (RDOSession.GetMessageFromID, RDOFolder.Items, etc), RDOContactItem will be returned if the message class is "IPM.Contact".
• New feature: added support for the olRTF format for the SaveAs method (RDOMail, MessageItem and Safe*Item objects). In the previous versions it was possible to save the contents of the RTFBody property, but it did not include the embedded OLE objects.
• Bug fix: SafeAppointmentItem.Body/HTMLBody/RTFBody returned empty string for the occurrences of a recurring appointment - that is, if the value of the AppointmentItem.RecurrenceState property of an object assigned to SafeAppointmentItem.Item was olApptOccurrence.
• Bug fix: some binary (8 bit) encoded MIME (EML) messages could not be imported.
• Bug fix: calling RDOFolder.Folders.Add caused MAPI_E_INVALID_PARAMETER error if the store is not Unicode enabled.
• Big fix: improved import of the MIME messages in the Far East languages (big5, GB18030, gb2312, hz-gb-2312, iso-2022-jp, etc charsets).
• Bug fix: MSG files accessed by RDOSession.GetMessageFromMsgFile were locked until the application was terminated.
• Bug fix: RDOStores.AddPSTStore method marked the last two parameters (Format and DisplayName) as optional in the type library, but still required them at run-time.
• Bug fix: if a call to RDOStores.AddPstStore specified a path to a corrupted PST file, the call failed, but the store (inaccessible) was still added to the list of the profile stores.
• Bug fix: calling RDOMail.PrintOut would leave outlook.exe running and (if the message was created on top of an MSG file) leave the MSG file locked until the process is terminated.
• Bug fix: error when calling RDOSession.LogonExchangeMailbox from ASP.Net or a Windows service.
• Bug fix: calling SafeTaskItem.Send sometimes resulted in unreadable Task Requests in the recipient's Inbox.
• Bug fix: RDOFolder.DefaultItemType returned wrong value for the Notes and Journal folder
• Bug fix: RDOMail.Move reset the PR_LAST_MODIFICATION_TIME and PR_CREATION_TIME properties (also PR_MESSAGE_DELIVERY_TIME and PR_SENDER_xxx for the Public Folder messages).
• Bug fix: attachment creation and last modifications times (when available) were lost when the following methods were called: CopyTo, SaveAs(..., olMsg), Import(..., olMsg), Attachments.Add.
• Bug fix: special characters (euro sign, etc) in some UTF-8 encoded EML files were imported incorrectly.
• Bug fix: Attachment.SaveAsFile() did not work for the embedded OLE attachments.
• Bug fix: RDOMail.EntryID sometimes returned short-term entry id of the message under Exchange.
• Bug fix: MSG files created by Redemption and then manually dragged back to Outlook created messages with duplicate attachments.
• Bug fix: calling SaveAs, Import, Attachments.Add, Attachment.SaveAsFile (RDOMail, Safe*Item and MessageItem objects) and specifying a file name with Unicode characters resulted in errors under certain circumstances.
• Bug fix: RDOExchangeMailboxStore.Owner returned an erroneous AddressEntry object if the given mailbox was not the default store in the current profile.
• Bug fix: RDOSession.GetAddressListFromID returned either "interface not supported" or "could not convert variant of type error to integer" errors.
• Bug fix: RDOAddressList.IsReadOnly property was returning TRUE when it was FALSE and vice versa.
• Bug fix: RDOAddressBook.ShowAddressBook returned E_INVALIDARG when the dialog was dismissed rather than MAPI_E_USER_CANCEL.
• Bug fix: setting a named property using the CDO 1.21 style property  name (e.g. "{0420060000000000C000000000000046}0x8005") failed.
• Bug fix: importing EML files with an empty To/CC/BCC MIME header created messages with an erroneous recipient.

10/30/2005

Version 4.0.0.452

• New set of objects - RDO (Redemption Data Objects). This standalone family of objects provides a CDO 1.21 replacement and exposes functionality not previously available in Redemption, such as access to the Outlook accounts (Outlook 2002 and up), support for multiple MAPI sessions, Access Control Lists (ACL) for the Exchange folders, access to the PST file name (for the PST stores) and much, much more.
• Bug fix: small text attachments with no line breaks were corrupted when saved as a MIME part of an EML file by Safe*Item.SaveAs(..., olRFC822)
• Bug fix: Changes to the embedded message attachments (Attachment.EmbeddedMsg) were not persisted when MessageItem.Save was called
• Improved EML file import performance (up to x10) for the large (>=10Mb) EML files.
• Bug fix: errors importing EML files with the binary (8 bit) MIME parts
• Bug fix: importing TNEF files did not remove old recipients and attachments.

02/07/2005

Version 3.4.0.402

• Bug fix: Attachment.SaveAsFile did not correctly handle attachments received from Macintosh
• Bug fix: Free/Busy information created by Outlook 97 was not correctly retrieved.
• Bug fix: RFC822 (EML) import did not handle UUEncoded messages correctly.
• Bug fix: RFC822 (EML) import/export did not handle large (couple hundred Mb or so) messages. Yes, people do have messages like that...
• Bug fix: SafeDistList.GetMember returned wrong entry ids for the members that were added from the address book (one-off addresses were Ok). These entry ids were mangled and could not be used to open the corresponding address entries (e.g. Namespace.GetRecipientFromEntryID). Note that Outlook Object Model has the same problem, while Redemption now works correctly.
• Bug fix: embedded OLE attachments in RTF messages were not correctly saved to MSG files (Safe*Item.SaveAs(..., olMsg)).
• Bug fix: SafeDistList.RemoveMember and SafeDistList.RemoveMemberEx could not remove the very last DL member.
• Bug fix: MSG files created by Redemption (Safe*Item.SaveAs..., olMsg) in Windows 2000/XP/2003 were not readable in Windows 9x/NT. Note that messages with the large number of recipients (>100) will still be incompatible.
• Bug fix: ProfMan.dll would hang when installed on a machine with Outlook 2000 in IMO mode (which does not support profiles anyway)
• Bug fix: calling SafeRecipients.ResolveAll would sometimes result in a catastrophic failure error if the number of recipients is large.
• New method: MAPIUtils.GetItemFromIDEx - unlike GetItemFromID (which takes message entry id and store entry id), this method allows to pass flags to be used when calling IMAPISession::OpenEntry. Most useful in Outlook 2003 to allow to bypass the cache and retrieve a live object from Exchange - pass the MAPI_NO_CACHE flag (0x200).
• Bug fix: previous versions of the Redemption.SafeCurrentUser object could not correctly retrieve the user identity under Outlook 2002 original/SP1/SP2 without Exchange (since MAPI spooler was removed). The latest version fixes the problem thanks to the newly documented IOlkAccountManager interface.
• Bug fix: sending messages in Outlook 2003/Exchange over SMTP sometimes caused recipients in the Sent Items folder to appear without names.
• Added olTemplate format support for the Safe*Item.SaveAs and MessageItem.SaveAs methods.
• MessageItem.HTMLBody property is now settable. It was read-only in the previous versions.
• Dozens of other small bug fixes and performance improvements.

04/20/2004

Version 3.4.0.325

• Redemption now supports standalone MSG files: use MAPIUtils.GetItemFromMsgFile(Path, CreateNew) to retrieve Redemption.MessageItem created on top of an MSG file.
• Redemption can now be installed even if the currently logged in Windows user is not an administrator or a power user. Normally, installing COM libraries involves modifying the HKEY_CLASSES_ROOT registry hive. Redemption can now install itself in the HKEY_CURRENT_USER hive. This will work in all versions of Windows except Windows NT. Note that Redemption also normally installs itself as an Exchange Client Extension to be able to retrieve some Extended MAPI objects directly from Outlook; if the user does not have write access to HKEY_LOCAL_MACHINE registry hive, Redemption will not be able to install itself as an ECE. It will still function normally in this case, but some things (especially if your code uses Redemption from within a COM add-in) can be slower.
• New Redemption object: Redemption.SafeReportItem - since ReportItem.Body is blocked in Outlook 2003 (and it does not work in the Outlook versions prior to Outlook 2002), there was clearly a need for the Outlook.ReportItem counterpart. Note that Outlook dynamically generates report's body from various properties in the message recipients table, so using a regular SafeMailItem object would not help. Since this is a new creatable COM object, you will need to customize redemption.dll again if you are using customization.
• New Redemption object: Redemption.SafeInspector - Outlook 2002 SP3 and Outlook 2003 block Inspector.HTMLEditor and Inspector.WordEditor properties. SafeInspector lets you work around the HTMLEditor and WordEditor properties block. Simply create an instance of the Redemption.SafeInspector object and set the SafeInspector.Item property to an instance of the Outlook.Inspector object. Note that Redemption.SafeInspector is fully supported on Windows XP/2003; on Windows 98/NT/2000 it requires Active Accessibility 2.0 RD to be installed in order to access the HTMLEditor and WordEditor objects (all other properties are supported under all configurations). As an added bonus, SafeInspector object also exposes Text, SelText, PlainTextEditor and RTFEditor properties which allow to manipulate the text displayed by an Outlook inspector no matter what kind of editor is used (Word, HTML, RTF, Plain Text). See SafeInspector help for more details.
• Bug fix: MSG files created by Redemption (Safe*Item.SaveAs(..., olMSG)) did not handle named properties correctly, sometimes resulting in MSG files unreadable by Outlook.
• Improved handling of the non-Latin character sets (especially Asian languages) by the Redemption RFC822 (EML) conversion (Safe*Item.SaveAs(..., olRFC822) and Safe*Item.Import(..., olRFC822)).
• Bug fix: SafeMailItem.HTMLBody and MessageItem.HTMLBody did not correctly handle charsets other than Western-European: characters from the upper half of the ASCII table were always HTML-encoded.
• Bug fix: calling SafeDistList.AddMember/RemoveMember would delete all existing DL entries - this bug was introduced in version 3.3.0.282.
• 2 new methods in SafeDistList: AddMemberEx(Name, Address, AddressType) - allows to add a new member without creating a Recipient object first. RemoveMemberEx(Index) allows to delete a member by its integer index rather than by passing a Recipient object.
• Safe*Item.SaveAs and MessageItem.SaveAs and  Safe*Item.Import/MessageItem.Import now support olTNEF (1025) format. Like the MSG format, TNEF preserves all MAPI properties; this is the format the infamous winmail.dat file attachment uses.
• Safe*Item.SaveAs and MessageItem.SaveAs now support olHTML format.
• Bug fix: created/last modified file dates were not persisted when adding an attachment and were not set on file when saving an attachment. Note that messages received over the internet do not persist file attachment dates.
• Bug fix: ProfMan library did not handle Unicode (PT_UNICODE) properties correctly when configuring services or accessing existing service or provider properties.
• ProfMan: added Profile.OpenProfileSection method (see example in the"Profiles" section)
• Added SafeMailItem.SenderEmailAddress property. This property was introduced to make Redemption consistent with Outlook 2003. The property returns the same value as SafeMailItem.Sender.Address or SafeMailItem.Fields(PR_SENDER_EMAIL_ADDRESS).
• Added AddressList.Default property (boolean, read/write) - allows to query the address list whether it is the default address list (displayed by default in the Address Book window) or allows to set the list as default. See also MAPIUtils.DefaultABListEntryID below.
• Added MAPIUtils.DefaultABListEntryID property (string, read/write) - allows to get/set the entry of the default Address Book container (list) first shown when the Address Book is displayed. You can set this property to AddressLists.ID to force the AB container to become default. See also AddressList.Default above.

11/17/2003

Version 3.3.0.282

The primary goal of this intermediate release was stability under every supported version of Outlook (98 through 2003) in every possible configuration, language pack or service pack whether Redemption is used in a COM add-in or a in separate exe. There were dozens of bugs fixed ranging from access violations to inconsistent behavior.

The only three new features are:

• MAPIUtils.HrGetPropList method - returns a collection of property tags exposed by a message (similar to what OutlookSpy displays when you click IMessage button).
• MessageItem.Import method - imports MSG or EML (RFC822) files into an existing Outlook message. Functions exactly like Safe*Item.Import, but does not reset the values of SentOn and Received properties when MailItem.Save is called (Outlook bug); use MAPIUtils.GetItemFromId to open an existing Outlook message as Redemption.MessageItem.
• Safe*Item.Recipients.AddEx() method - Unlike Recipients.Add, AddEx takes 4 parameters (name, address, address type and recipient type, all but the first one are optional). This method allows to add a recipient in a single call. If you specify all 4 parameters, the additional benefit is that the recipient is automatically resolved, there is no need to resolve it later.

08/15/2003

Version 3.3.0.252

• Redemption now implements HTMLBody property (blocked in Outlook 2003) on all of Safe*Item objects. The Body property was already implemented in the previous versions.
• MAPITable object now supports filtering and sorting. Compared to OOM, filtering is not as easy as using Table.Restrict, but Redemption.MAPITable supports every restriction kind available in Extended MAPI (search for substrings, property size, property existence, etc).
• RFC822 import (Safe*Item.Import) and export (Safe*Item.SaveAs(olRFC822, ...)) were completely rewritten with added full support for HTML, embedded images and message attachments.
• Three additional MAPIUtils methods - HrLocalToGMT, HrGMTToLocal and GetNamesFromIDs. Most Extended MAPI PT_SYSTIME properties are stored in the GMT timezone, while OOM exposes datetime properties in local time; HrLocalToGMT and HrGMTToLocal allow for an easy conversion between the two. GetNamesFromIDs allows to retrieve the GUID and ID given an integer property tag - this method is essentially the opposite of GetIDsFromNames (just as the name implies).
• You can now set binary properties (PT_BINARY, such as PR_SENT_MAIL_ENTRYID) as strings; Redemption will convert them to binary (the string must be a hex representation of the binary property, such as MailItem.EntryID). These properties are still returned as variant arrays; use MAPIUtils.HrArrayToString to convert to a string. You can of course still set the binary properties as variant arrays.
• Redemption now handles recipient resolution much better - if you supply an e-mail address or a name/address pair to the Recipients collection, Redemption will resolve such addresses without opening an address book resulting in a significant performance increase. The same goes for one-off addresses: Redemption can parse one-off addresses without opening the address book; e.g. accessing Safe*Item.Sender property will be much faster in case of one-off addresses.
• SafeContactItem.SaveAs() now supports olVCard as one of its formats

03/12/2003

Version 3.2.0.221

• New object MAPITable. Click here for more details. This object allows to read a set of properties from multiple messages in a folder in a single call; this can be up to 1,000 times faster than looping through the messages.
• New property: SafeMAPIFolder.DeletedItems - returns a collection of soft-deleted messages (see IMAPIFolder|GetContentsTable - SHOW_SOFT_DELETES tab in OutlookSpy). This collection is Exchange specific, DeletedItems will return NULL if the folder is not located in an Exchange store. DeletedItems collection has the same properties and methods as the SafeItems object with one additional method: Restore(Index).
• Bug fix: Safe*Item.Fields() and MAPIUtils.HrGetOneProp() sometimes failed for large string and binary properties.
• Two additional methods for the MAPIUtils object - HrArrayToString() and HrStringToArray(). Unlike CDO, Redemption returns and expects binary (PT_BINARY) properties as a variant arrays, while CDO works with the binary properties converted to strings. OOM also converts binary properties to strings (most notably when it comes to entry ids - e.g. MailItem.EntryID, Namespace.GetItemFromID(), etc).
• Performance optimization - setting Safe*Item.Item property now takes at least 50% less time.
• Bug fix: setting multivalued (PT_MV_xxx) Extended MAPI properties using Safe*Item.Fields and MAPIUtils.HrSetOneProp() did not work

12/25/2002

Version 3.1.0.182

• Bug fix: under certain conditions AuthKey was shared between customized versions of Redemption.
• Bug fix: after creating an instance of any Redemption object the current directory was changed to "C:\Program Files\Common Files\System\Mapi\1033\NT" (or a similar directory where MAPI files are located)
• SafeXXXItem objects' Import() and SaveAs() methods can now import/save RFC822 (.EML) format messages. Known limitation - embedded message attachments export support is limited in this version. To use this format, specify olRFC822 (1024) as the Type.
• Performance optimization: Free/Busy information retrieval was slow for the Exchange Servers with a large number of mailboxes (> 20,000)
• Bug fix: Free/Busy information returned by Redemption sometimes differed from the Free/Busy information returned by the Outlook Object Model due to a round-off error.
• Bug fix: Email1EntryID, Email2EntryID, and Email3EntryID properties of SafeContactItem returned empty values.
• New feature: SafeDistList object now implements AddMember/AddMembers/RemoveMember/RemoveMembers methods and MemberCount property.
• New feature: MAPIUtils object implements CreateRecipient() method. Unlike the corresponding Namespace.CreateRecipient() method, in addition to the Name parameter, Redemption has two optional parameters ShowDialog (default = false) and ParentWnd which let you optionally display the Address Book dialog if the specified name cannot be resolved or if it is ambiguous.
• New feature: MAPIUtils object has an additional property (read-only) - CurrentProfileName.
• ProfMan bug fix: Services.Add() sometimes failed to return the newly created service, returning an existing service instead. Most often this happened with some existing PST files.

11/02/2002

Version 3.0.0.152

• New method MAPIUtils.GetItemFromID() - works just like Namespace.GetItemFromID() in Outlook Object Model, but returns MessageItem object which a close replica of Message in CDO. Useful if you need to open a message with a custom message class (such as one of the hidden messages) without Outlook's warning that a custom form cannot be found.
• FreeBusy on Recipients and AddressEntries finally works.
• You can access embedded message attachments - Attachment object now has EmbeddedMsg property (returns MessageItem object). In case of a regular attachment this property is NULL.
• MAPIFolder now has Items collection (in addition to the HiddenItems collection). Lets you access any message in a folder as MessageItem object without using Outlook Object Model first.
• You can now customize the Redemption library and provide custom class names and GUIDs (available in the distributable version of Redemption only). The customized version of Redemption is guaranteed not to interact with other instances of the Redemption library, either original or customized.

07/01/2002

Version 2.0.0.536

• Address Lists are supported. Create an instance of Redemption.AddressLists to access all available address lists in the current profile. All properties and methods match those of the corresponding Outlook Object Model objects.
• MAPIUtils.AddressBookFilter - when you set this property, Address Book shown with a call to MAPIUtils.AddressBook will only display the address book container(s) whose name matches the AddressBookFilter. E.g. if you set AddressBookFilter to "Customers", AddressBook() method will only display subcontainers named "Customers"
• SafeAppointmentItem.Send and SafeTaskItem.Send finally work. Unlike regular items (Mail, etc), appointments and tasks create a brand new message and send it when Send() is called, regular items just send themselves. 
• Redemption now respects the value set to the SentOnBehalfOfName property when sending a message. Note that this property only works under Exchange and the user must be allowed to send of behalf of the specified user.
• Redemption.dll now implements an Outlook extension (works in all versions of Outlook) which does nothing but provide IMAPISession Extended MAPI interface to various Redemption objects using Running Objects Table (ROT). This can result in a significant performance increase as Redemption no longer needs to call MAPILogonEx() to obtain IMAPISession.
• Hidden folder items (associated messages in MAPI'ese) are supported. See code sample for an details
• MAPIUtils.DeliverNow can now accept an additional flag (fqAsync - 8) to force an asynchronous Send/Receive

03/29/2002

• All Safe*Item objects have an additional method - GetIDsFromNames(). This method is required if you need to access named (in the 0x8000 and above range) properties. See HTML message with embedded image example
• Fixed SafeCurrentUser bug: under certain conditions it would report identity defined by a POP3/SMTP service rather than Exchange.

03/19/2002

• Redemption.dll now links to the correct version of mapi32.dll even if Outlook is not the default mail client.

03/18/2002

• New object - SafeDistList. The object overrides one (blocked) method  - GetMember(Index) and returns SafeRecipient object

03/13/2002

• Attachment.SaveAs() can now save embedded messages as MSG files
• SafeMailItem.ReplyRecipients collection can now be used to set reply recipients without triggering the security prompts

02/21/2002

• MAPIUtils.DeliverNow() now takes two optional arguments which allow you to specify whether messages should be downloaded, uploaded, or both. See Redemption Objects for details.
• Fixed bug: adding properties using Safe*Item.Fields collection sometimes failed
• Properties can be removed by setting them to Nothing, e.g. SafeMailItem.Fields(&H0037001E)=Nothing
• Fixed bug: adding attachments using Safe*Item.Attachments.Add() method resulted in attachments having a display name "Attachment". 
• Safe*Item.SaveAs() can now be used to save messages in olMsg (3) and olText (0) formats.

02/05/2002

• Fixed: Redemption.dll was statically linked to several functions in mapi32.dll making it impossible to install Redemption on systems where Outlook is not the default e-mail client.
• SafeMailItem.Send method was updated to work with CDO messages, e.g. you can now assign CDO Message object to the SafeMailItem.Item property and successfully call SafeMailItem.Send

01/31/2002

• All Redemption items have a CopyTo() method which allows to copy a Redemption item into any Outlook Object Model or CDO message.
• Redistributable version of Redemption now includes ProfMan - a utility to manipulate MAPI profiles.
• You can now open IMAPITable Extended MAPI properties (see MAPIUtils.HrGetOneProp or SafeMailItem.Fields) - if the property can be opened as IMAPITable (such PR_EMS_AB_PUBLIC_DELEGATES on AddressEntry object), Redemption will return SafeTable object. Right now SafeTable has a single property - Count, which returns the number of rows in the table. If you need further support (e.g. quering each row's properties), please let us know.
• Fixed a bug when setting properties using Fields collection on Items, Attachments and Recipients.

11/20/2001

• SafeRecipient.Resolve() method now takes an optional boolean parameter - ShowDialog (default false). If passed false, Resolve() tries to silently resolve the recipient. If passed true, and the recipient cannot be resolved, Redemption displays a dialog box prompting to manually resolve the name.