09/02/2010
Version 5.0.0.2174
New features:
Redemption now includes the 64 bit versions of Redemption.dll and ProfMan.dll for use with the 64 bit version of Outlook 2010.
Both 32 and 64 bit versions of Redemption can be customized using the customize.exe tool (included with the distributable version only) or used without registering the dlls in the registry (a-la registry-free COM) or even using a manifest - see Directly loading Redemption for more information.
|
'Add a quick step that marks the selected message "Due Tomorrow" |
Added the ability to set the account order (RDOAccountOrderList.SetItem)
Added RDOReminders.EnableStoreReminders method that verifies that the Reminders search folder exists and recreates it if necessary.
Added RDOSession.ConnectEncryptData property. Setting this property to true will allow RDOSession.LogonExchangeMailbox to connect to an Exchange server that might require data encryption (on by default in Exchange 2010).
Added RDOMail.GetProps method that allows to retrieve multiple MAPI properties in a single call. Other RDOMail-derived objects (RDOContactItem, RDOAppointmentItem etc) also expose this method:
|
set Session = CreateObject("Redemption.RDOSession") |
RDOAddressEntry.CopyTo now allows to pass either an RDOMail object (or any of its descendants, such as RDOContactItem) or an RDOFolder object as a parameter to export the address entry to a contact or a distribution list.
Added olRtf format to the list of supported import formats for the RDOMail.Import and Safe*Item.Import. methods. Unlike setting the RtfBody property, importing from a file ensures that the data does not get truncated at the very first 0x0 byte (which can happen if RTF contains embedded binary objects).
Added RDOFolderSynchronizer.OnProgress event.
Added RDORecurrencePattern.CalendarType property.
Added RDOException.StartDateTime / EndDateTime / OriginalStartDate / OverrideXyz and ModifiedXyz properties (where Xyz are Subject, MeetingType, ReminderDelta, ReminderSet, Location, BusyStatus, Attachment, SubType, AppointmentColor). These properties allow to retrieve some commonly used properties from the exception blob without having to open the exception appointment itself.
RDOExchangeMailboxStore.ServerVersion and ServerName properties now fully support Outlook 2010 (which allows multiple Exchange servers to be used in the same profile).
Added RDOExchangeMailboxStore.GetNicknames and RDOPstStore.GetNicknames to support Outlook 2010 (which stores nicknames in the default message store in the profile).
RDOSession.GetNicknames method now allows to pass an RDOStore object as a parameter (besides previously supported profile or file name).
Added ShowSenderPhoto method to the SafeInspector object.
Bug fixes:
Search folders created by Redemption (RDOStore2.Searches and RDOFolders.AddSearchFolder) were always static under Exchange 2010.
Outlook sometimes showed Exchange stores added using RDOStores.AddDelegateExchangeMailBoxStore as "Microsoft - Exchange information store"
RDOStores.AddDelegateExchangeMailBoxStore did not support Unicode names passed as an argument.
Tasks created by Redemption (RDOTaskItem) did not display Due Date in OWA (Outlook Web Access).
Recurring tasks creates by Redemption (RDOTaskItem will not display recurring icon in Outlook.
Special characters from the upper half of the ASCII table were removed from the RDOMail.HTMLBody property.
Redemption could not generate recurring tasks (RDOTaskItem) with the weekly recurrence pattern and RDORecurrencePattern.Regenerate = TRUE.
RDORecurrencePattern.MonthOfYear returned incorrect value for the yearly occurring appointments with Interval > 1.
Redemption could not create,
modify or delete
recipients from an instance of a recurring activity:
|
set Session =
CreateObject("Redemption.RDOSession") |
Accessing RDOExchangeStore.ServerDN property sometimes produced an error.
HTMLBody property returned by several Redemption objects (RDOMail, SafeMailItem, etc) sometimes returned HTML with black-on-black text for the messages in the plain text or RTF formats.
RDOFolder.CopyTo method created messages in the unsent state when copying between different stores.
RDOLinks.Remove method did not update the underlying parent message.
Setting multivalued Unicode string properties (PT_MV_UNICODE) using RDOMail.Fields[] produced garbage.
RDOAppointmentItem.AllDayEvent property returned true even though appointment duration was not an an even multiplier of 1440 (the number of minutes in a day). This change was made to be consistent with the Outlook Object Model.
RDOSession.GetSharedMailbox sometimes raises "Could not find the store DN" error when accessing mailboxes hosted on the Exchange 2007/2010.
RDOOutOfOfficeAssistant.OutOfOfficeText property sometimes did not match what was displayed by the Outlook OOF assistant if there were other rules triggered in the Out-Of-Office state.
RDOAppointmentItem objects created by Redemption did not have the GlobalAppointmentID property set immediately after the creation.
RDOCategory.Color property was off by 1 - e.g. instead of olCategoryColorRed (1) it returned olCategoryColorOrange (2), etc.
RDOCategories.Add raised an error if the name of the new category contained a dot (".").
DateTime properties retrieved from or set by Redemption were rounded up to the nearest millisecond due to the way FILETIME type (used by MAPI) was converted to/from the DateTime type used by COM.
RDOUserProperties collection failed to load and process any properties that had large length (>255) formula or validation formula. All subsequent properties in the collection were ignored.
GetSharedMailboxEx method was missing from the RDOSession object. It was still present on the RDOStores object.
SafeMailItem.ReplyRecipients.AddEx did nothing.
RDOAppointmentItem.MeetingStatus sometimes returned 7 (which is not one of the valid rdoMeetingStatus enums) instead of olMeetingCanceled (5).
RDODistListItem object could not handle large distribution lists created or modified by Outlook 2007 SP2 or Outlook 2010.
Opening PST files through RDOSession.LogonPstStore or RDOStores.AddPstStore leaked a handle to the folder where the PST file resides, making it impossible to delete the folder until the application terminated.
Changes to e-mail filtering options made by the RDOJunkEmailOptionsobject were not visible in Outlook 2010.
Changes made to the start/end dates of instances of a recurring appointment (exceptions) were off by 1 hour if DST switch occurred between the first start date of the appointment and the start date of the instance.
Adding attachments to the instances of recurring activities resulted in attachments with no file name and/or no file data.
01/03/2010
Version 4.8.0.1184
New features:
Added
RDOCategories object to the
RDOSession and
RDOStore2 objects. Note that since
categories are exposed both on the session and store level, this allows to
manage other Exchange user's categories using a store retrieved from
RDOSession.GetSharedMailbox.
|
'Enumerate all categories defined in the default store set Session =
CreateObject("Redemption.RDOSession") |
Exposed RDOJunkEmailOptions object through the RDOSession.JunkEmailOptions and RDOExchangeMailboxStore.JunkEmailOptions properties that represents Junk E-mail settings for either a MAPI session (profile-wide) or for a particular Exchange mailbox.
In case of the profile settings (returned by RDOSession.JunkEmailOptions), the data is stored locally in the registry (profile section) and, if the primary store in the profile is an Exchange mailbox, in the Exchange mailbox as an extended rule.
RDOExchangeMailboxStore.JunkEmailOptions returns Exchange mailbox specific settings that can be different from the settings for the current user in case of a delegate mailbox (see the example below).
The example below prints all blocked sender addresses and domains in the current profile.
|
set Session =
CreateObject("Redemption.RDOSession") |
The example below opens the mailbox owned by another Exchange user and adds a domain to the list of trusted senders.
|
set Session =
CreateObject("Redemption.RDOSession") |
Added RDOSession.ParentWindow property, which can be set either to a window handle (HWND) or to an object that supports the IOleWindow interface (such as Explorer or Inspector objects in the Outlook Object Model). Setting that property allows MAPI to display dialog boxes when needed, for example when logging to a profile (Logon, LogonExchangeMailbox), opening a message store (LogonPstStore, AddPstStoreWithPassword, GetStoreFromID, GetSharedMailbox) or when resoling names (ResolveName, Resolve, etc).
|
set Session =
CreateObject("Redemption.RDOSession") |
Added MAPITags enum with over 5000 symbolic MAPI tags:
|
RDOMail msg;... string headers = (string)msg.get_Fields(MAPITags.PR_TRANSPORT_MESSAGE_HEADERS_W); MessageBox.Show(headers); |
Added MAPICode enum with about 70 symbolic MAPI error codes:
|
RDOAddressEntry addressEntry;try { addressEntry = rdoSession.AddressBook.ResolveName("dmitry", false, 0); } catch(COMException e) { string errorMsg; if (e.ErrorCode == (int)MAPICode.MAPI_E_AMBIGUOUS_RECIP) errorMsg = "The name is ambiguous"; else if (e.ErrorCode == (int)MAPICode.MAPI_E_NOT_FOUND) errorMsg = "The name cannot be found"; else errorMsg = "the name could not be resolved"; MessageBox.Show(errorMsg, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } |
Added RDOExchangeManageStore object exposed through the RDOExchangeMailboxStore
and
RDOExchangePublicFoldersStore
objects (ExchangeManageStore property). This object wraps the
functionality of the IExchangeManageStore, IExchangeManageStore3
and IExchangeManageStore4 Extended MAPI objects and allows, among
other things, to retrieve the list of mailboxes hosted by a particular
Exchange server.
The example below retrieves the list of mailboxes hosted on the same Exchanger server as the default store in the current profile.
|
skPrimaryExchangeMailbox = 3 |
Added pffHidePublicFoldersStore flag to the RDOSession.PickFolder method.
Added RDOSession.FastShutdownSupported property and RDOSession.DoFastShutdown method. See Steve Griffin's blog for more information: http://blogs.msdn.com/stephen_griffin/archive/2009/03/03/fastest-shutdown-in-the-west.aspx
Added RDOFolderFields.Find method.
Added olFolderSuggestedContacts (30) to the rdoDefaultFolders enum to support the new "Suggested Contacts" default folder in Outlook 2010.
Added RELOP_MEMBER_OF_DL to the PropsRelop enum.
Added RDOACE.IsDefault / IsAnonymous properties.
RDOFolder2.GetAllChildFolders method which returns all child subfolders, not just immediate subfolders. Note that only the Exchange provider in the online mode supports this functionality. All other store providers will still only return immediate child subfolders.
Added olMHTMLNoHeaders to the rdoSaveAsType enum to be used by the RDOMail.SaveAs and Safe*Item.SaveAs methods. Just like olMHTML, it creates an MHT file with the HTML body and embedded images, but does not add Subject/From/etc visible headers..
MAPITable.ExecSQL and RDOItems.Find/Restrict now fully support Unicode in the SQL queries.
Added RDOFolder2.CustomViewsOnly property.
Added RDOAttachment.ContentLocation / ContentID / MimeSequence / MimeTag properties.
Added RDORecurrencePattern.PatternEndKind property.
Added
RDOSession.ConnectIgnoreNoPF
property. Setting that property to true has the same effect as creating the
previously supported (since version 4.5)
special registry key to force Redemption to use the CONNECT_IGNORE_NO_PF
flag when calling RDOSession.LogonExchangeMailbox.
Bug fixes:
RDOAddressBook.ResolveName and RDOAddressList.ResolveName could not handle Unicode names under certain conditions.
Saving appointments in the HTML or MHTML formats (Safe*Item.SaveAs and RDOMail.SaveAs) resulted in an error.
Calling RDOTaskItem.MarkComplete did not create a new task with the new start date for the recurring tasks set to regenerate (RDORecurrencePattern.Regenerate = TRUE)
Accessing any RDORule object leaked several MAPI COM objects resulting in MAPI_E_NOT_ENOUGH_MEMORY after processing a large number of rules or logging to too many MAPI session.
Modifying exceptions of recurring appointments (RDOAppointmentItem) returned by RDOException.Item resulted in the MAPI_E_NO_ACCESS error when calling RDOAppointmentItem.Save.
Setting multivalued (PT_MV) properties using MAPIProp.Fields or RDOUserProperty.Value (for olKeywords property type) to a value which is not a variant array, was ignored.
Saving attachments (RDOAttachment.SaveAsFile) consumed twice the amount of RAM as the size of the attachment data. This version will never read the whole attachment blob when saving.
Events raised by the RDOStore, RDOFolder and RDOMail objects sometimes were not raised for the applications created in VB6.
Embedded message attachments saved using RDOAttachment.SaveAsFile did not preserver Unicode data.
Outlook reported "invalid recurrence" for the recurring appointments created by Redemption and spawning across midnight.
Repeatedly calling RDORecipients.Resolve sometimes resulted in an access violation
Retrieving a non-custom property using RDOUserProperties.Find(..., FALSE), always returned an instance of the RDOUserProperty object with the Value property being an empty variant.
RDOContactItem.Email1DisplayName property sometimes returned an empty string.
Creating a custom search that explicitly specified "Junk E-mail" or "Deleted
Items" folders as the folders to search in produced no results since
Redemption always excluded these folders. Note that the Outlook Object Model
and Outlook UI exhibit the same problem.
|
'Create a custom search that display messages from the "Junk E-mail" folder 'with the "Redemption" or "Outlook" words in the message body or subject. set Session = CreateObject("Redemption.RDOSession") |
Using COUNT in a SQL expression without a WHERE clause (e.g. "SELECT Count(*) from Folder") executed by MAPITable.ExecSQL returned no rows.
RDOSession.PickFolder method sometimes produced an error if a new folder was created while the Pick Folder dialog was being displayed.
Recurring appointments with exceptions created by Redemption sometimes could not be accessed with Outlook 2003 or XP.
Monthly recurring tasks created with Redemption always had RDORecurrencePattern.Regenerate = TRUE.
RDOPstStore.ValidateIPMTree method did not create the Reminders hidden search folder.
RDOUserProperty.Value property (unlike that in the Outlook Object Model) always returned olKeywords properties as variant arrays rather than ";" separated strings. Setting the Value property to a ";" separated string also did not split the string into elements.
Deleting instances of recurring appointments (RDOAppointmentItem.Delete) sometimes produced appointments that looked in Outlook as if the deleted instances still existed.
RDOAttachment.FileName and RDOAttachment.DisplayName properties sometimes returned ANSI values instead of Unicode even if the parent store was Unicode-enabled under Outlook 2003.
Setting PT_LONG MAPI properties using RDOMail.Fields[] in .Net to a variable declared as long had no effect.
Even after explicitly unsubscribing from an event handler when using Redemption in .Net, the event sink (internal object created by .Net run-time) stayed alive resulting in a small memory leak.
Calling RDOSession.Logoff sometimes resulted in an assertion error
Accessing RDOMail.Body property for a large number of messages from multiple threads sometimes resulted in an access violation.
Creating a new appointment (RDOItems.Add("IPM.Appointment") resulted in an error if the current time zone name did not exist in the "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Time Zones" registry key.
RDOSession.PickFolder displayed hidden folders not visible in the Outlook UI (such as "Conversation Action Settings" and "Quick Step Settings" folders created by Outlook 2010).
Canceling ICS sync by setting the Cancel parameter to true in the RDOFolderSynchronizer.OnSyncFolder / OnSyncHiddenItem / OnSyncItem events caused the sync to raise an error resulting in the previous sync data to be unavailable.
Various date/time properties will now return 1/1/4501 instead of 1/1/4500 when the value is not set. This behavior is now consistent with the Outlook Object Model.
02/16/2009
Version 4.7.0.1026
New features:
Added RDOStore2.Searches collection that represents Search Folders visible through the Outlook UI. Note that a raw MAPI search folder (exposed by the RDOSearchFolder Redemption object) is not normally visible in the Search Folders node in Outlook. Both template based ("Large Messages", "Unread Mail", etc) and custom searches are supported.
|
set Session =
CreateObject("Redemption.RDOSession")
'Add a search folder that shows messages larger than 1MB. set NewSearch = Searches.AddLargeMessages("Huge Messages", 1048576) ' > 1MB
'Add a search folder that shows all received messages with the word "Redemption" in the message body or subject.
strSQL = "(Body LIKE '%Redemption%') OR (Subject LIKE
'%Redemption%') " |
Added the ability to enumerate nicknames (the contents of the Outlook NK2 files) for any given profile or an explicitly specified NK2 file. See RDONickNames object for more information.
|
'print out all nicknames
and their SMTP addresses from the
current profile |
Creation of recurrence exceptions is now supported. The previous versions allowed to access, but not to create exceptions:
|
set Session =
CreateObject("Redemption.RDOSession") |
Added RDOAddressBook.ResolveNameEx and RDOAddressList.ResolveNameEx methods that allow to resolve a given name against all containers in the search path or the given address book container respectively. Note that unlike the ResolveName method (which returns a single RDOAddressEntry object and raises an error if no matches or more than one match is found), ResolveNameEx return a list of matches (RDOAddressEntries object) that can contain 0, 1 or more entries.
|
set Session =
CreateObject("Redemption.RDOSession") |
Added RDOMail.DownloadPictures
property.
Added
RDORuleAction.Flags and
ActionFlavor properties.
Added support for the
vCalendar (olVCal) and iCalendar (olICal) formats for the
RDOMail.SaveAs /
Safe*Item.SaveAs methods.
Added AllDayEvent,
BusyStatus, Duration, End, IsRecurring, Location
and Start properties to the RDOMeetingItem
object to facilitate access to the meeting properties without having to
create/access the corresponding appointment item (RDOAppointmentItem)
using RDOMeetingItem.GetAssociatedAppointment
method.
Added
RDOSession.Version property.
Added RDOStore.OnMessageCreatedEx
/ OnMessageDeletedEx / OnMessageModifiedEx events. These
events provide message as well as the parent folder entry ids.
OnMessageMovedEx event was already exposed in the previous version.
Saving Outlook items (RDOMail.SaveAs /
Safe*Item.SaveAs) in the HTML
(olHTML) and MHTML (olMHTL) formats now produces items specific
(appointment, contact, task, etc) data rather than treating all items as
regular messages.
Added RDOExchangePublicFoldersStore.GetFolderFromSourceKey and RDOExchangePublicFoldersStore.GetMessageFromSourceKey methods (RDOExchangeMailboxStore already had these methods).
Bug fixes:
After installing Redemption, you might lose the ability to type Unicode characters in Outlook.
Redemption methods would sometimes hang when used in application with no UI (such as console or service apps).
RDOSession.LogonPstStore, RDOStores.AddDelegateExchangeMailBoxStore, RDOStores.FindExchangePublicFoldersStore methods sometimes hanged in multithreaded service or console applications.
Redemption will now attempt to load the new Windows 2008 Server compatible standalone version of MAPI if it is installed (see http://blogs.msdn.com/stephen_griffin/archive/2008/06/02/this-just-in-mapi-and-windows-server-2008-now-get-along.aspx ).
RDOMail.SaveAs / Safe*Item.SaveAs did not encode Far Eastern characters correctly in the vCard format (olVCard).
RDORssItem.FullArticle property did not handle HTTP redirect responses (301 HTTP response code).
Retrieving olPublicFoldersAllPublicFolders or olPublicFoldersFavorites folders using RDOSession.GetDefaultFolder always returned "Public Folders store cannot have default folders" error.
Meeting cancelation subject prefix was not localized - "Canceled" prefix was always used.
Specifying To/CC/BCC properties in a SQL statement (MAPITable.ExecSQL, RDOItems.Find/Restrict, etc) searched on a substring in the PR_DISPLAY_TO / PR_DISPLAY_CC / PR_DISPLAY_BCC properties rather than PR_EMAIL_ADDRESS or PR_DISPLAY_NAME in the message recipients table (PR_MESSAGE_RECIPIENTS).
When a user property (RDOUserProperty.Value) was set to a DateTime value, Redemption converted it from UTC to the local time zone on the MAPI level rather than from the local time zone to UTC.
Setting RDORecurrencePattern.Regenerate property to true had no effect for the tasks set to occur every day.
Setting RDORecurrencePattern.Interval property to a value > 1 had no effect for the appointments and tasks set to occur yearly.
Setting RDORecurrencePattern.PatternEndDate property created a series that ended on the day preceding the specified date.
Setting a currency MAPI property from .Net (which uses VT_DECIMAL variant rather than VT_CURRENCY) had no effect for RDOUserProperty.Value and MAPIProp.Fields.
Saving RSS messages in the text (olTxt) and RTF (olRtf) formats (RDORssItem.SaveAs and Safe*Item.SaveAs methods) produced header different from that created by Outlook.
RDOAttachment.FileName and Safe*Item.FileName properties replaced some Unicode characters with "_".
Importing MIME messages (RDOMail.Import) under the Exchange version of MAPI sometimes took a long time.
RDOUserProperties collection (returned by RDOMail.UserProperties and other objects derived from RDOMail, such as RDOContactItem, RDOAppointmentItem, etc). did not return user properties defined by the custom form used to create the item (if custom form defined in the folder was used).
Saving a contact in the vCard (olVCard) format (RDOMail/Safe*Item.SaveAs) did not export the contact picture.
RDOAppointmentItem.ClearRecurrencePattern did not remove existing exceptions.
Instances of the private recurring appointments in cached delegate mailboxes in Outlook 2007 (RDOAppointmentItem) returned by the RDORecurrencePattern.GetOccurence method returned wrong values for the End and Duration properties.
RDOUserProperties collection sometimes returned fewer properties than reported by the Outlook Object Model, especially if the item was created using a custom form.
Setting RDOContactItem.Email1EntryID / Email2EntryID / Email3EntryID properties to an entry id of of a GAL address entry object resulted in Outlook displaying the EX address (rather than SMTP) in the "Address Cards" view.
RDOFolder2.GetActivitiesForTimeRange and RDORecurrencePattern.GetOccurence returned erroneous entries (off by 1 week) for weekly recurring activities spanning across January 1 (of any year).
08/08/2008
Version 4.6.0.924
New features:
Added
RDOSession.PickFolder
method. An almost exact replica of the
Namespace.PickFolder method in Outlook Object Model, but allows to
specify the initially selected folder, hide all folders above the specified
folder, hide the "New" button, display only folders of a specific
type, etc. This method does not use the Outlook
Object Model or any Outlook libraries (besides MAPI), and works under both the Outlook and
standalone (Exchange) versions of MAPI.
Added
RDOAccounts.DisplayAccountList and
RDOAccounts.DisplayNewAccountWizard
methods that display "Account Settings" and "Add New E-mail Account" dialogs
respectively (Outlook 2002 and up only).
Added
RDOUserProperties collection
(returned by
RDOMail.UserProperties and other
objects derived from
RDOMail, such as
RDOContactItem,
RDOAppointmentItem,
etc).
RDOUserProperties collection contains custom properties of an Outlook item. Note that this
collection is compatible with the UserProperties collection in the Outlook Object Model (see
MSDN), but also exposes properties not exposed through the Outlook Object
Model, such as RDOUserProperty.Printable
and RDOUserProperty.Required.
On the MAPI level user property values are stored as regular named MAPI properties, but Outlook also stores the properties definitions in a special binary blob, which in turn is stored in another named MAPI property on the item.
You can access the values of the user properties using MAPIProp.Fields, but RDOUserProperties collection allows to modify the user properties definitions, which are also used when designing a form or when managing folder fields (see RDOFolderFields).
|
set Session =
CreateObject("Redemption.RDOSession") |
Added
RDORssItem object
representing an RSS feed item in one of the Outlook folders.
Added RDOPstStore.ValidateIPMTree method that validates and creates (if necessary) all the default folders (see example). The folder names are set according to the current Office (or Windows if Office is not installed) locale. The following default folders will be created if they do not already exist: Inbox, Outbox, Deleted Items, Sent Items, Calendar, Contacts, Drafts, Journal, Notes, Tasks, Junk E-mail, Folder Views, Common Views, Search Root, IPM Subtree.
|
set Session = CreateObject("Redemption.RDOSession") 'open or create a new
PST store 'make sure the new PST
store has all the default folders 'now create a new contact in the default Contacts folder of the newly created PST store set Contact =
Store.GetDefaultFolder(olFolderContacts).Items.Add |
Added RDOSession.CurrentWindowsUser property representing the identity of the current Windows user. Accessing this property does not require an active MAPI session, i.e. it can be accessed even if Logon or LogonExchangeMailbox methods had not been called.
|
set Session =
CreateObject("Redemption.RDOSession") |
Language specific Redemption features
are now localized for the following languages: English, German, Spanish,
French, Italian, Portuguese, Russian, Chinese, Japanese, Korean.
Redemption
determines the Office locale first by reading the OfficeUILanguage
value from the HKEY_CURRENT_USER\Software\Microsoft\Shared key. If
the key is missing (e.g. if the Exchange Server version of MAPI is used), it
uses the current Windows user locale (GetUserDefaultLCID)
The following Redemption methods
and properties are affected:
names of the folders created by
RDOPstStore.ValidateIPMTree,
headers created by
RDOMail/Safe*Item.SaveAs(...,
<olTxt, olHtml, olRtf>), RDORecurrencePattern.Description,
RDOSession.PickFolder.
Added
RDOFolderSynchronizer
events (OnSyncItem, OnSyncHiddenItem, OnSyncFolder). Besides
providing a callback each time a message or folder is being synchronized,
the event handlers can also cancel the sync. For the modified messages (Kind
= sikChanged), you can also provide a target message (RDOMail) in some other
folder that ICS will automatically populate with the latest values
of the source message properties.
Added RDORecurrencePattern.Description property (read/write).
|
set Session =
CreateObject("Redemption.RDOSession") set Appt =
Session.GetDefaultFolder(olFolderCalendar).Items.Add myRecurrPatt.Description =
"Every 3 days right on time!"
|
Added MHTML (HTML with embedded
images) format support for the RDOMail.SaveAs and
Safe*Item.SaveAs methods (use
olMHTML (=1027) as a Type parameter).
Added "COUNT(*)" operator support to the
MAPITable.ExecSQL method, e.g. "SELECT Count(*) from Folder where
Subject like '%code%' "
Added RDOFolder2 / RDOSearchFolder.ShowItemCount property.
Implemented RDOAppointmentItem.Respond method. This method previously returned a "not implemented" error.
Added RDOMail.Modified property.
RDORecurrencePattern.Interval property now works for the yearly recurring appointments. You need to have KB950219 update (Outlook 2007) installed to take advantage of this new functionality in the Outlook UI.
Added RDOIMAPAccount.SaveSentMessageFolder property (Outlook 2007 specific)
Bug fixes:
Setting RDOMail.HTMLBody property to a string that contained some special characters (such as ™) sometimes resulted in an empty HTML body.
Weekly recurring appointments created by Redemption (RDOAppointmentItem object) sometimes were invisible in Outlook for the locales where the first day of the week is anything but Sunday.
Setting the RDOAppointmentItem.AllDayEvent property forced the Duration property to be set to 1440 (1 day) even if it was previously set to 2 or more days.
MAPITable.ExecSQL failed to return any records when a restriction was specified against a GAL Address Book container contents table.
Specifying "TOP n" in a SELECT statement in MAPITable.ExecSQL returned substantially more rows than specified (up to 20 times more).
RDOException.Deleted returned true and RDOException.Item returned null for some recurrence exceptions moved to a different date.
Importing MIME files (RDOMail.Import / Safe*Item.Import) with large (>100Mb) attachments sometimes resulted in out-of-memory errors.
RDOMail.Import and RDOAttachments.Add sometimes returned an error that the specified file did not exist.
RDOReportItem.FindOriginalItem sometimes failed to return the original item from the Sent Items folder (or some other folder where it was stored after being sent).
Calling RDOMail.Move(TargetFolder) where TargetFolder was an RDOFolder object from a different MAPI session (e.g. a temporary session returned by the RDOSession.LogonPstStore method) sometimes resulted in the target store being added to the list of stores.
Under the Exchange version of MAPI, Redemption behaved as if the Exchange stores were not Unicode enabled.
RDOMail.Size property returned 0 for the messages created on top of MSG files, such as those returned by the RDOSession.CreateMessageFromMsgFile or RDOSession.GetMessageFromMsgFile methods.
Calling RDORecipients.AddEx (for the RDORecipients objects returned by the RDOAddressBook.ShowAddressBook method) raised the "This feature is not supported yet" error.
Passing null (Nothing in VB) rather than Empty (Empty.Value in .Net) to the RDOAddressBook.ShowAddressBook method for the first parameter (Recipients) raised an error.
Using the "Subject" property name in the "ORDER BY" SQL clause used by the MAPITable.ExecSQL and RDOItems.Find/Restrict methods returned no data when executed under an online Exchange store.
Using the "Subject" property name in the RDOItems.Sort method did not sort the messages in the collection.
Importing a UTF-8 encoded MIME message under the Exchange Server version of MAPI sometimes set the PR_INTERNET_CPID MAPI property to 1200, which made the message unreadable by Outlook.
RDOOutOfOfficeAssistant.OutOfOfficeText property could not be set to a true Unicode string.
MAPITable.ExecSQL method sometimes returned an error for the folders with no messages if no WHERE clause was specified.
RDOSession.GetDefaultFolder and RDOStore.GetDefaultFolder methods returned null when olFolderRssSubscriptions or olFolderToDo were specified as an argument.
For the password protected PST stores, RDOSession.LogonPstStore method (and subsequent attempts to access to the PST store) still prompted for the password even if the password was specified as an argument when the RDOSession.LogonPstStore method was called.
EML files created by Redemption under the Exchange version of MAPI did not include the Received, X-MSMail-Priority and Thread-Index MIME headers.
Accessing the ReplyRecipients collection of the RDOMail objects created on top of the MSG files (RDOSession.CreateMessageFromMsgFile and RDOSession.GetMessageFromMsgFile) sometimes produces errors at a later point when objects were released, especially when processing a large number of the MSG files in the .Net environment.
RDOTaskItem.IsRecurring returned false for the recurring tasks created using RDO.
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") 'set Folder = Session.GetDefaultFolder(olFolderInbox) '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 set SyncItems = Synchonizer.SyncItems(strPreviousSyncData) 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:" EndIf
' IMPORTANT: remember/store the sync cookie to be used next
time when calling SyncItems (see above) |
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 |
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
set Table = CreateObject("Redemption.MAPITable") |
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 |
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") '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 |
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") |
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") |
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") 'let Redemption know which
properties we will be requesting later 'read the
properties specified in the MAPITable.Columns property above |
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
Version 1.1.0.471.
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
Version 1.1.0.467.
Redemption.dll now links to the correct version of mapi32.dll even if Outlook is not the default mail client.
03/18/2002
Version 1.1.0.465.
New object - SafeDistList. The object overrides one (blocked) method - GetMember(Index) and returns SafeRecipient object
03/13/2002
Version 1.1.0.461.
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
Version 1.1.0.443.
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
Version 1.1.0.423.
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
Version 1.1.0.404.
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
Version 1.1.0.382.
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.