Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1418 insertions, 0 deletions

diff --git a/comm/mailnews/addrbook/src/nsAbOutlookDirectory.cpp b/comm/mailnews/addrbook/src/nsAbOutlookDirectory.cpp
new file mode 100644
index 0000000000..77568a62f2
--- /dev/null
+++ b/comm/mailnews/addrbook/src/nsAbOutlookDirectory.cpp
@@ -0,0 +1,1418 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsAbOutlookDirectory.h"
+#include "nsAbWinHelper.h"
+
+#include "nsString.h"
+#include "nsAbDirectoryQuery.h"
+#include "nsIAbBooleanExpression.h"
+#include "nsIAbManager.h"
+#include "nsAbQueryStringToExpression.h"
+#include "nsEnumeratorUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "mozilla/Logging.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsCRTGlue.h"
+#include "nsArrayUtils.h"
+#include "nsMsgUtils.h"
+#include "nsQueryObject.h"
+#include "mozilla/Services.h"
+#include "nsIObserverService.h"
+#include "mozilla/JSONStringWriteFuncs.h"
+
+#define PRINT_TO_CONSOLE 0
+#if PRINT_TO_CONSOLE
+#  define PRINTF(args) printf args
+#else
+static mozilla::LazyLogModule gAbOutlookDirectoryLog("AbOutlookDirectory");
+#  define PRINTF(args) \
+    MOZ_LOG(gAbOutlookDirectoryLog, mozilla::LogLevel::Debug, args)
+#endif
+
+nsAbOutlookDirectory::nsAbOutlookDirectory(void)
+    : nsAbDirProperty(),
+      mDirEntry(nullptr),
+      mCurrentQueryId(0),
+      mSearchContext(-1) {
+  mDirEntry = new nsMapiEntry;
+}
+
+nsAbOutlookDirectory::~nsAbOutlookDirectory(void) {
+  if (mDirEntry) {
+    delete mDirEntry;
+  }
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsAbOutlookDirectory, nsAbDirProperty,
+                            nsIAbDirectoryQuery, nsIAbDirSearchListener)
+
+NS_IMETHODIMP nsAbOutlookDirectory::Init(const char* aUri) {
+  nsresult rv = nsAbDirProperty::Init(aUri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString entry;
+  makeEntryIdFromURI(kOutlookDirectoryScheme, mURI.get(), entry);
+  nsAbWinHelperGuard mapiAddBook;
+  nsAutoString unichars;
+  ULONG objectType = 0;
+
+  if (!mapiAddBook->IsOK()) return NS_ERROR_FAILURE;
+
+  mDirEntry->Assign(entry);
+  if (!mapiAddBook->GetPropertyLong(*mDirEntry, PR_OBJECT_TYPE, objectType)) {
+    PRINTF(("Cannot get type.\n"));
+    return NS_ERROR_FAILURE;
+  }
+  if (!mapiAddBook->GetPropertyUString(*mDirEntry, PR_DISPLAY_NAME_W,
+                                       unichars)) {
+    PRINTF(("Cannot get name.\n"));
+    return NS_ERROR_FAILURE;
+  }
+
+  m_AddressList = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mCardList = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (objectType == MAPI_DISTLIST) {
+    m_IsMailList = true;
+    SetDirName(unichars);
+    // For a mailing list, we get all the cards into our member variable.
+    rv = GetCards(m_AddressList, nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else {
+    m_IsMailList = false;
+    if (unichars.IsEmpty()) {
+      SetDirName(u"Outlook"_ns);
+    } else {
+      SetDirName(unichars);
+    }
+    // First, get the mailing lists, then the cards.
+    rv = GetNodes(m_AddressList);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = GetCards(mCardList, nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+// nsIAbDirectory methods
+
+NS_IMETHODIMP nsAbOutlookDirectory::GetDirType(int32_t* aDirType) {
+  NS_ENSURE_ARG_POINTER(aDirType);
+  *aDirType = nsIAbManager::MAPI_DIRECTORY_TYPE;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::GetURI(nsACString& aURI) {
+  if (mURI.IsEmpty()) return NS_ERROR_NOT_INITIALIZED;
+
+  aURI = mURI;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::GetChildNodes(
+    nsTArray<RefPtr<nsIAbDirectory>>& aNodes) {
+  aNodes.Clear();
+  // Mailing lists don't have childnodes.
+  if (m_IsMailList || !m_AddressList) {
+    return NS_OK;
+  }
+
+  uint32_t count = 0;
+  nsresult rv = m_AddressList->GetLength(&count);
+  NS_ENSURE_SUCCESS(rv, rv);
+  aNodes.SetCapacity(count);
+  for (uint32_t i = 0; i < count; i++) {
+    nsCOMPtr<nsIAbDirectory> dir = do_QueryElementAt(m_AddressList, i, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    aNodes.AppendElement(&*dir);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::GetChildCardCount(uint32_t* aCount) {
+  nsIMutableArray* srcCards = m_IsMailList ? m_AddressList : mCardList;
+  return srcCards->GetLength(aCount);
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::GetChildCards(
+    nsTArray<RefPtr<nsIAbCard>>& aCards) {
+  aCards.Clear();
+
+  // Not a search, so just return the appropriate list of items.
+  nsIMutableArray* srcCards = m_IsMailList ? m_AddressList : mCardList;
+  uint32_t count = 0;
+  nsresult rv = srcCards->GetLength(&count);
+  NS_ENSURE_SUCCESS(rv, rv);
+  aCards.SetCapacity(count);
+  for (uint32_t i = 0; i < count; i++) {
+    nsCOMPtr<nsIAbCard> card = do_QueryElementAt(srcCards, i, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    aCards.AppendElement(&*card);
+  }
+  return NS_OK;
+}
+
+// This is an exact copy of nsAbOSXDirectory::HasCard().
+NS_IMETHODIMP nsAbOutlookDirectory::HasCard(nsIAbCard* aCard, bool* aHasCard) {
+  NS_ENSURE_ARG_POINTER(aCard);
+  NS_ENSURE_ARG_POINTER(aHasCard);
+
+  nsresult rv = NS_OK;
+  uint32_t index;
+  if (m_IsMailList) {
+    if (m_AddressList) rv = m_AddressList->IndexOf(0, aCard, &index);
+  } else if (mCardList)
+    rv = mCardList->IndexOf(0, aCard, &index);
+
+  *aHasCard = NS_SUCCEEDED(rv);
+
+  return NS_OK;
+}
+
+// This is an exact copy of nsAbOSXDirectory::HasDirectory().
+NS_IMETHODIMP nsAbOutlookDirectory::HasDirectory(nsIAbDirectory* aDirectory,
+                                                 bool* aHasDirectory) {
+  NS_ENSURE_ARG_POINTER(aDirectory);
+  NS_ENSURE_ARG_POINTER(aHasDirectory);
+
+  *aHasDirectory = false;
+
+  uint32_t pos;
+  if (m_AddressList &&
+      NS_SUCCEEDED(m_AddressList->IndexOf(0, aDirectory, &pos)))
+    *aHasDirectory = true;
+
+  return NS_OK;
+}
+
+// This is an exact copy of nsAbOSXDirectory::CardForEmailAddress().
+NS_IMETHODIMP
+nsAbOutlookDirectory::CardForEmailAddress(const nsACString& aEmailAddress,
+                                          nsIAbCard** aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  *aResult = nullptr;
+
+  if (aEmailAddress.IsEmpty()) return NS_OK;
+
+  nsIMutableArray* list = m_IsMailList ? m_AddressList : mCardList;
+
+  if (!list) return NS_OK;
+
+  uint32_t length;
+  nsresult rv = list->GetLength(&length);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAbCard> card;
+
+  for (uint32_t i = 0; i < length && !*aResult; ++i) {
+    card = do_QueryElementAt(list, i, &rv);
+    if (NS_SUCCEEDED(rv)) {
+      bool hasEmailAddress = false;
+
+      rv = card->HasEmailAddress(aEmailAddress, &hasEmailAddress);
+      if (NS_SUCCEEDED(rv) && hasEmailAddress) NS_IF_ADDREF(*aResult = card);
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsAbOutlookDirectory::ExtractCardEntry(nsIAbCard* aCard,
+                                                nsCString& aEntry) {
+  aEntry.Truncate();
+
+  nsCString uri;
+  aCard->GetPropertyAsAUTF8String("OutlookEntryURI", uri);
+
+  // If we don't have a URI, uri will be empty. makeEntryIdFromURI doesn't set
+  // aEntry to anything if uri is empty, so it will be truncated, allowing us
+  // to accept cards not initialized by us.
+  makeEntryIdFromURI(kOutlookCardScheme, uri.get(), aEntry);
+  return NS_OK;
+}
+
+nsresult nsAbOutlookDirectory::ExtractDirectoryEntry(nsIAbDirectory* aDirectory,
+                                                     nsCString& aEntry) {
+  aEntry.Truncate();
+  nsCString uri;
+  nsresult rv = aDirectory->GetURI(uri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  makeEntryIdFromURI(kOutlookDirectoryScheme, uri.get(), aEntry);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::DeleteCards(
+    const nsTArray<RefPtr<nsIAbCard>>& aCards) {
+  nsresult retCode = NS_OK;
+  nsAbWinHelperGuard mapiAddBook;
+
+  if (!mapiAddBook->IsOK()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsAutoCString cardEntryString;
+  nsMapiEntry cardEntry;
+
+  for (auto card : aCards) {
+    retCode = ExtractCardEntry(card, cardEntryString);
+    if (NS_SUCCEEDED(retCode) && !cardEntryString.IsEmpty()) {
+      cardEntry.Assign(cardEntryString);
+      bool success = false;
+      if (m_IsMailList) {
+        nsAutoCString uri(mURI);
+        // Trim off the mailing list entry ID from the mailing list URI
+        // to get the top-level directory entry ID.
+        nsAutoCString topEntryString;
+        int32_t slashPos = uri.RFindChar('/');
+        uri.SetLength(slashPos);
+        makeEntryIdFromURI(kOutlookDirectoryScheme, uri.get(), topEntryString);
+        nsMapiEntry topDirEntry;
+        topDirEntry.Assign(topEntryString);
+        success =
+            mapiAddBook->DeleteEntryfromDL(topDirEntry, *mDirEntry, cardEntry);
+      } else {
+        success = mapiAddBook->DeleteEntry(*mDirEntry, cardEntry);
+      }
+      if (!success) {
+        PRINTF(("Cannot delete card %s.\n", cardEntryString.get()));
+      } else {
+        if (m_IsMailList) {
+          // It appears that removing a card from a mailing list makes
+          // our list go stale, so refresh it.
+          m_AddressList->Clear();
+          GetCards(m_AddressList, nullptr);
+        } else if (mCardList) {
+          uint32_t pos;
+          if (NS_SUCCEEDED(mCardList->IndexOf(0, card, &pos)))
+            mCardList->RemoveElementAt(pos);
+        }
+        retCode = NotifyItemDeletion(card, true);
+        NS_ENSURE_SUCCESS(retCode, retCode);
+
+        card->SetDirectoryUID(EmptyCString());
+      }
+    } else {
+      PRINTF(("Card doesn't belong in this directory.\n"));
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::DeleteDirectory(
+    nsIAbDirectory* aDirectory) {
+  if (!aDirectory) {
+    return NS_ERROR_NULL_POINTER;
+  }
+  nsresult retCode = NS_OK;
+  nsAbWinHelperGuard mapiAddBook;
+  nsAutoCString dirEntryString;
+
+  if (!mapiAddBook->IsOK()) {
+    return NS_ERROR_FAILURE;
+  }
+  retCode = ExtractDirectoryEntry(aDirectory, dirEntryString);
+  if (NS_SUCCEEDED(retCode) && !dirEntryString.IsEmpty()) {
+    nsMapiEntry directoryEntry;
+
+    directoryEntry.Assign(dirEntryString);
+    if (!mapiAddBook->DeleteEntry(*mDirEntry, directoryEntry)) {
+      PRINTF(("Cannot delete directory %s.\n", dirEntryString.get()));
+    } else {
+      uint32_t pos;
+      if (m_AddressList &&
+          NS_SUCCEEDED(m_AddressList->IndexOf(0, aDirectory, &pos)))
+        m_AddressList->RemoveElementAt(pos);
+
+      // Iterate over the cards of the directory to find the one
+      // representing the mailing list and also remove it.
+      if (mCardList) {
+        nsAutoCString listUID;
+        aDirectory->GetUID(listUID);
+
+        uint32_t nbCards = 0;
+        nsresult rv = mCardList->GetLength(&nbCards);
+        NS_ENSURE_SUCCESS(rv, rv);
+        for (uint32_t i = 0; i < nbCards; i++) {
+          nsCOMPtr<nsIAbCard> card = do_QueryElementAt(mCardList, i, &rv);
+          NS_ENSURE_SUCCESS(rv, rv);
+          nsAutoCString cardUID;
+          rv = card->GetUID(cardUID);
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (cardUID.Equals(listUID)) {
+            mCardList->RemoveElementAt(i);
+            break;
+          }
+        }
+      }
+      retCode = NotifyItemDeletion(aDirectory, false);
+      NS_ENSURE_SUCCESS(retCode, retCode);
+    }
+  } else {
+    PRINTF(("Directory doesn't belong to this folder.\n"));
+  }
+  return retCode;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::AddCard(nsIAbCard* aCard,
+                                            nsIAbCard** aNewCard) {
+  NS_ENSURE_ARG_POINTER(aCard);
+  NS_ENSURE_ARG_POINTER(aNewCard);
+
+  *aNewCard = nullptr;
+  nsresult retCode = NS_OK;
+  nsAbWinHelperGuard mapiAddBook;
+  nsMapiEntry newEntry;
+  nsAutoCString cardEntryString;
+  bool isNewCard = false;
+  nsCOMPtr<nsIAbDirectory> topDir;
+
+  if (!mapiAddBook->IsOK()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsAutoCString ourUID;
+  if (!m_IsMailList) {
+    // We're not dealing with a mailing list, so just create a new entry.
+    if (!mapiAddBook->CreateEntry(*mDirEntry, newEntry)) {
+      return NS_ERROR_FAILURE;
+    }
+    isNewCard = true;
+    GetUID(ourUID);
+  } else {
+    nsAutoCString dirURI(mURI);
+    // Trim off the mailing list entry ID from the mailing list URI
+    // to get the top-level directory entry ID.
+    nsAutoCString topEntryString;
+    int32_t slashPos = dirURI.RFindChar('/');
+    dirURI.SetLength(slashPos);
+    makeEntryIdFromURI(kOutlookDirectoryScheme, dirURI.get(), topEntryString);
+    nsMapiEntry topDirEntry;
+    topDirEntry.Assign(topEntryString);
+
+    // Add a card to a mailing list. We distinguish two cases:
+    // If there is already an Outlook card, we can just add it.
+    // If none exists, we need to create it first. Outlook has an option
+    // that allows a creation of a mailing list member solely in the list
+    // but we don't support this for now to avoid more MAPI complication.
+    retCode = ExtractCardEntry(aCard, cardEntryString);
+    if (NS_SUCCEEDED(retCode) && !cardEntryString.IsEmpty()) {
+      newEntry.Assign(cardEntryString);
+    } else {
+      if (!mapiAddBook->CreateEntry(topDirEntry, newEntry)) {
+        return NS_ERROR_FAILURE;
+      }
+      isNewCard = true;
+    }
+    nsAutoString display;
+    nsAutoString email;
+    aCard->GetDisplayName(display);
+    aCard->GetPrimaryEmail(email);
+    if (!mapiAddBook->AddEntryToDL(topDirEntry, *mDirEntry, newEntry,
+                                   display.get(), email.get())) {
+      return NS_ERROR_FAILURE;
+    }
+    // The UID of the card is the top directory's UID.
+    nsCOMPtr<nsIAbManager> abManager(
+        do_GetService("@mozilla.org/abmanager;1", &retCode));
+    NS_ENSURE_SUCCESS(retCode, retCode);
+    retCode = abManager->GetDirectory(dirURI, getter_AddRefs(topDir));
+    NS_ENSURE_SUCCESS(retCode, retCode);
+    topDir->GetUID(ourUID);
+  }
+
+  newEntry.ToString(cardEntryString);
+  nsAutoCString cardURI(kOutlookCardScheme);
+  cardURI.Append(cardEntryString);
+
+  nsCOMPtr<nsIAbCard> newCard;
+  retCode = OutlookCardForURI(cardURI, getter_AddRefs(newCard));
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  // Make sure the card has a UID before setting its directory UID.
+  // This is a bit of a hack. If we get the UID of the card before setting its
+  // directory UID, we can avoid an unwanted `ModifyCard()` call inside
+  // `nsAbCardProperty::SetUID()`.
+  nsCString dummy;
+  newCard->GetUID(dummy);
+  newCard->SetDirectoryUID(ourUID);
+
+  if (isNewCard) {
+    retCode = newCard->Copy(aCard);
+    NS_ENSURE_SUCCESS(retCode, retCode);
+
+    // Set a decent display name of the card. This needs to be set
+    // on the card and not on the related contact via `SetPropertiesUString()`.
+    nsAutoString displayName;
+    newCard->GetDisplayName(displayName);
+    mapiAddBook->SetPropertyUString(newEntry, PR_DISPLAY_NAME_W,
+                                    displayName.get());
+
+    if (m_IsMailList) {
+      // Observed behavior for a new card in a mailing list is that
+      // Outlook returns __MailUser__ as first name. That value was
+      // previously set as display name when creating the bare card.
+      nsAutoString firstName;
+      newCard->GetFirstName(firstName);
+      if (StringBeginsWith(firstName,
+                           NS_LITERAL_STRING_FROM_CSTRING(kDummyDisplayName))) {
+        newCard->SetFirstName(EmptyString());
+      }
+    }
+
+    retCode = ModifyCardInternal(newCard, true);
+    NS_ENSURE_SUCCESS(retCode, retCode);
+  }
+
+  if (m_IsMailList) {
+    m_AddressList->AppendElement(newCard);
+    if (isNewCard) {
+      // Add the new card to the cards of the top directory as well.
+      nsAbOutlookDirectory* topDirOL =
+          static_cast<nsAbOutlookDirectory*>(topDir.get());
+      topDirOL->mCardList->AppendElement(newCard);
+    }
+  } else {
+    mCardList->AppendElement(newCard);
+  }
+
+  NotifyItemAddition(newCard, true);
+
+  newCard.forget(aNewCard);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::DropCard(nsIAbCard* aData,
+                                             bool needToCopyCard) {
+  nsCOMPtr<nsIAbCard> addedCard;
+  return AddCard(aData, getter_AddRefs(addedCard));
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::AddMailList(nsIAbDirectory* aMailList,
+                                                nsIAbDirectory** addedList) {
+  NS_ENSURE_ARG_POINTER(aMailList);
+  NS_ENSURE_ARG_POINTER(addedList);
+  if (m_IsMailList) return NS_OK;
+
+  nsAbWinHelperGuard mapiAddBook;
+  nsMapiEntry newEntry;
+  nsAutoCString newEntryString;
+
+  if (!mapiAddBook->IsOK()) return NS_ERROR_FAILURE;
+
+  nsAutoString name;
+  nsresult rv = aMailList->GetDirName(name);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!mapiAddBook->CreateDistList(*mDirEntry, newEntry, name.get()))
+    return NS_ERROR_FAILURE;
+
+  newEntry.ToString(newEntryString);
+  nsAutoCString uri(mURI);
+  nsAutoCString topEntryString;
+  makeEntryIdFromURI(kOutlookDirectoryScheme, uri.get(), topEntryString);
+  uri.Append('/');
+  uri.Append(newEntryString);
+
+  RefPtr<nsAbOutlookDirectory> directory = new nsAbOutlookDirectory;
+
+  // We will later need the URI of the parent directory, so store it here.
+  directory->mParentEntryId = topEntryString;
+
+  // Light-weight initialisation. `nsAbOutlookDirectory::Init()` will get
+  // the object type wrong since we don't have cards yet and scan for cards
+  // which we don't have yet.
+  rv = directory->nsAbDirProperty::Init(uri.get());
+  NS_ENSURE_SUCCESS(rv, rv);
+  directory->mDirEntry->Assign(newEntryString);
+  directory->m_IsMailList = true;
+  directory->m_AddressList = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAbDirectory> newList = do_QueryObject(directory);
+
+  rv = newList->CopyMailList(aMailList);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Also create a card to match the list.
+  // That needs to happen before the notification.
+  nsAutoCString cardURI(kOutlookCardScheme);
+  cardURI.Append(newEntryString);
+  nsCOMPtr<nsIAbCard> newCard =
+      do_CreateInstance("@mozilla.org/addressbook/cardproperty;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  newCard->SetPropertyAsAUTF8String("OutlookEntryURI", cardURI);
+
+  // This is a bit of a hack. If we set the UID of the card before setting its
+  // directory UID, we can avoid an unwanted `ModifyCard()` call inside
+  // `nsAbCardProperty::SetUID()`.
+  nsAutoCString listUID;
+  newList->GetUID(listUID);
+  newCard->SetUID(listUID);
+  nsAutoCString ourUID;
+  GetUID(ourUID);
+  newCard->SetDirectoryUID(ourUID);
+  newCard->SetIsMailList(true);
+  newCard->SetMailListURI(uri.get());
+  newCard->SetDisplayName(name);
+  newCard->SetLastName(name);
+
+  mCardList->AppendElement(newCard);
+  m_AddressList->AppendElement(newList);
+
+  NotifyItemAddition(newList, false);
+
+  newList.forget(addedList);
+  return rv;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::EditMailListToDatabase(
+    nsIAbCard* listCard) {
+  nsresult rv;
+  nsString name;
+  nsAbWinHelperGuard mapiAddBook;
+
+  if (!mapiAddBook->IsOK()) return NS_ERROR_FAILURE;
+
+  rv = GetDirName(name);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!mapiAddBook->SetPropertyUString(*mDirEntry, PR_DISPLAY_NAME_W,
+                                       name.get()))
+    return NS_ERROR_FAILURE;
+
+  // Iterate over the cards of the parent directory to find the one
+  // representing the mailing list and also change its name.
+  nsAutoCString uri(mURI);
+  // Trim off the mailing list entry ID from the mailing list URI
+  // to get the top-level directory entry ID.
+  nsAutoCString topEntryString;
+  int32_t slashPos = uri.RFindChar('/');
+  uri.SetLength(slashPos);
+  nsCOMPtr<nsIAbManager> abManager(
+      do_GetService("@mozilla.org/abmanager;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIAbDirectory> parent;
+  rv = abManager->GetDirectory(uri, getter_AddRefs(parent));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString listUID;
+  GetUID(listUID);
+
+  uint32_t nbCards = 0;
+  nsAbOutlookDirectory* olDir =
+      static_cast<nsAbOutlookDirectory*>(parent.get());
+  rv = olDir->mCardList->GetLength(&nbCards);
+  NS_ENSURE_SUCCESS(rv, rv);
+  for (uint32_t i = 0; i < nbCards; i++) {
+    nsCOMPtr<nsIAbCard> card = do_QueryElementAt(olDir->mCardList, i, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString cardUID;
+    rv = card->GetUID(cardUID);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (cardUID.Equals(listUID)) {
+      card->SetDisplayName(name);
+      break;
+    }
+  }
+
+  nsAutoCString dirUID;
+  if (listCard) {
+    // For mailing list cards, we use the UID of the top level directory.
+    listCard->GetDirectoryUID(dirUID);
+    NotifyItemModification(listCard, true, dirUID.get());
+  }
+  nsCOMPtr<nsIAbDirectory> dir = do_QueryObject(this);
+  // Use the UID of the parent.
+  parent->GetUID(dirUID);
+  NotifyItemModification(dir, false, dirUID.get());
+  return NS_OK;
+}
+
+static nsresult FindPrimaryEmailCondition(nsIAbBooleanExpression* aLevel,
+                                          nsAString& value) {
+  if (!aLevel) {
+    return NS_ERROR_NULL_POINTER;
+  }
+  nsresult retCode = NS_OK;
+  nsTArray<RefPtr<nsISupports>> expressions;
+
+  retCode = aLevel->GetExpressions(expressions);
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  for (uint32_t i = 0; i < expressions.Length(); ++i) {
+    RefPtr<nsIAbBooleanConditionString> condition =
+        do_QueryObject(expressions[i], &retCode);
+    if (NS_SUCCEEDED(retCode)) {
+      nsCString name;
+      retCode = condition->GetName(getter_Copies(name));
+      NS_ENSURE_SUCCESS(retCode, retCode);
+      if (name.EqualsLiteral("PrimaryEmail")) {
+        // We found a leaf in the boolean expression tree that compares
+        // "PrimaryEmail". So return the value and be done.
+        retCode = condition->GetValue(getter_Copies(value));
+        return retCode;
+      }
+      continue;
+    }
+
+    RefPtr<nsIAbBooleanExpression> subExpression =
+        do_QueryObject(expressions[i], &retCode);
+    if (NS_SUCCEEDED(retCode)) {
+      // Recurse into the sub-tree.
+      retCode = FindPrimaryEmailCondition(subExpression, value);
+      // If we found our leaf there, we're done.
+      if (NS_SUCCEEDED(retCode)) return retCode;
+    }
+  }
+  return NS_ERROR_UNEXPECTED;
+}
+
+static nsresult GetConditionValue(nsIAbDirectoryQueryArguments* aArguments,
+                                  nsAString& value) {
+  if (!aArguments) {
+    return NS_ERROR_NULL_POINTER;
+  }
+  nsresult retCode = NS_OK;
+
+  nsCOMPtr<nsISupports> supports;
+  retCode = aArguments->GetExpression(getter_AddRefs(supports));
+  NS_ENSURE_SUCCESS(retCode, retCode);
+  nsCOMPtr<nsIAbBooleanExpression> booleanQuery =
+      do_QueryInterface(supports, &retCode);
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  // Outlook can only query the PR_ANR property. So get its value from the
+  // PrimaryEmail condition.
+  retCode = FindPrimaryEmailCondition(booleanQuery, value);
+  return retCode;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::DoQuery(
+    nsIAbDirectory* aDirectory, nsIAbDirectoryQueryArguments* aArguments,
+    nsIAbDirSearchListener* aListener, int32_t aResultLimit, int32_t aTimeout,
+    int32_t* aReturnValue) {
+  if (!aArguments || !aListener || !aReturnValue) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // The only thing we can search here is PR_ANR. All other properties are
+  // skipped. Note that PR_ANR also searches in the recipient's name and
+  // e-mail address.
+  // https://docs.microsoft.com/en-us/office/client-developer/outlook/mapi/address-book-restrictions
+  // states:
+  // Ambiguous name restrictions are property restrictions using the PR_ANR
+  // property to match recipient names with entries in address book containers.
+
+  SRestriction restriction;
+  SPropValue val;
+  restriction.rt = RES_PROPERTY;
+  restriction.res.resProperty.relop = RELOP_EQ;
+  restriction.res.resProperty.ulPropTag = PR_ANR_W;
+  restriction.res.resProperty.lpProp = &val;
+  restriction.res.resProperty.lpProp->ulPropTag = PR_ANR_W;
+
+  nsAutoString value;
+  nsresult rv = GetConditionValue(aArguments, value);
+  NS_ENSURE_SUCCESS(rv, rv);
+  restriction.res.resProperty.lpProp->Value.lpszW = value.get();
+
+  rv = ExecuteQuery(&restriction, aListener, aResultLimit);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aReturnValue = ++mCurrentQueryId;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::StopQuery(int32_t aContext) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::Search(const nsAString& query,
+                                           const nsAString& searchString,
+                                           nsIAbDirSearchListener* listener) {
+  nsresult retCode = NS_OK;
+
+  // Note the following: We get a rather complicated query passed here from
+  // preference mail.addr_book.quicksearchquery.format.
+  // Outlook address book search only allows search by PR_ANR, which is a fuzzy
+  // Ambiguous Name Restriction search.
+
+  retCode = StopSearch();
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  nsCOMPtr<nsIAbBooleanExpression> expression;
+
+  nsCOMPtr<nsIAbDirectoryQueryArguments> arguments = do_CreateInstance(
+      "@mozilla.org/addressbook/directory/query-arguments;1", &retCode);
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  retCode = nsAbQueryStringToExpression::Convert(NS_ConvertUTF16toUTF8(query),
+                                                 getter_AddRefs(expression));
+  NS_ENSURE_SUCCESS(retCode, retCode);
+  retCode = arguments->SetExpression(expression);
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  retCode = arguments->SetQuerySubDirectories(true);
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  return DoQuery(this, arguments, listener, -1, 0, &mSearchContext);
+}
+
+nsresult nsAbOutlookDirectory::StopSearch(void) {
+  return StopQuery(mSearchContext);
+}
+
+// nsIAbDirSearchListener
+NS_IMETHODIMP nsAbOutlookDirectory::OnSearchFinished(
+    nsresult status, bool complete, nsITransportSecurityInfo* secInfo,
+    nsACString const& location) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbOutlookDirectory::OnSearchFoundCard(nsIAbCard* aCard) {
+  mCardList->AppendElement(aCard);
+  return NS_OK;
+}
+
+nsresult nsAbOutlookDirectory::ExecuteQuery(SRestriction* aRestriction,
+                                            nsIAbDirSearchListener* aListener,
+                                            int32_t aResultLimit)
+
+{
+  if (!aListener) return NS_ERROR_NULL_POINTER;
+
+  nsresult retCode = NS_OK;
+
+  nsCOMPtr<nsIMutableArray> resultsArray(
+      do_CreateInstance(NS_ARRAY_CONTRACTID, &retCode));
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  retCode = GetCards(resultsArray, aRestriction);
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  uint32_t nbResults = 0;
+  retCode = resultsArray->GetLength(&nbResults);
+  NS_ENSURE_SUCCESS(retCode, retCode);
+
+  if (aResultLimit > 0 && nbResults > static_cast<uint32_t>(aResultLimit)) {
+    nbResults = static_cast<uint32_t>(aResultLimit);
+  }
+
+  uint32_t i = 0;
+  nsCOMPtr<nsIAbCard> card;
+
+  for (i = 0; i < nbResults; ++i) {
+    card = do_QueryElementAt(resultsArray, i, &retCode);
+    NS_ENSURE_SUCCESS(retCode, retCode);
+
+    aListener->OnSearchFoundCard(card);
+  }
+
+  aListener->OnSearchFinished(NS_OK, true, nullptr, ""_ns);
+  return retCode;
+}
+
+// This function expects the aCards array to already be created.
+nsresult nsAbOutlookDirectory::GetCards(nsIMutableArray* aCards,
+                                        SRestriction* aRestriction) {
+  nsAbWinHelperGuard mapiAddBook;
+
+  if (!mapiAddBook->IsOK()) return NS_ERROR_FAILURE;
+
+  nsMapiEntryArray cardEntries;
+  LPSRestriction restriction = (LPSRestriction)aRestriction;
+
+  if (!mapiAddBook->GetCards(*mDirEntry, restriction, cardEntries)) {
+    PRINTF(("Cannot get cards.\n"));
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv;
+  nsAutoCString ourUID;
+  if (m_IsMailList) {
+    // Look up the parent directory (top-level directory) in the
+    // AddrBookManager. That relies on the fact that the top-level
+    // directory is already in its map before being initialised.
+    nsCOMPtr<nsIAbManager> abManager(
+        do_GetService("@mozilla.org/abmanager;1", &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString dirURI(kOutlookDirectoryScheme);
+    dirURI.Append(mParentEntryId);
+    nsCOMPtr<nsIAbDirectory> owningDir;
+    rv = abManager->GetDirectory(dirURI, getter_AddRefs(owningDir));
+    NS_ENSURE_SUCCESS(rv, rv);
+    owningDir->GetUID(ourUID);
+  } else {
+    GetUID(ourUID);
+  }
+
+  rv = NS_OK;
+
+  for (ULONG card = 0; card < cardEntries.mNbEntries; ++card) {
+    nsAutoCString cardEntryString;
+    nsAutoCString cardURI(kOutlookCardScheme);
+    nsCOMPtr<nsIAbCard> childCard;
+    cardEntries.mEntries[card].ToString(cardEntryString);
+    cardURI.Append(cardEntryString);
+
+    rv = OutlookCardForURI(cardURI, getter_AddRefs(childCard));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // Make sure the card has a UID before setting its directory UID.
+    // This is a bit of a hack. If we get the UID of the card before setting its
+    // directory UID, we can avoid an unwanted `ModifyCard()` call inside
+    // `nsAbCardProperty::SetUID()`.
+    nsCString dummy;
+    childCard->GetUID(dummy);
+    childCard->SetDirectoryUID(ourUID);
+
+    aCards->AppendElement(childCard);
+  }
+  return rv;
+}
+
+nsresult nsAbOutlookDirectory::GetNodes(nsIMutableArray* aNodes) {
+  NS_ENSURE_ARG_POINTER(aNodes);
+
+  nsAbWinHelperGuard mapiAddBook;
+  nsMapiEntryArray nodeEntries;
+
+  if (!mapiAddBook->IsOK()) return NS_ERROR_FAILURE;
+
+  if (!mapiAddBook->GetNodes(*mDirEntry, nodeEntries)) {
+    PRINTF(("Cannot get nodes.\n"));
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIAbManager> abManager(
+      do_GetService("@mozilla.org/abmanager;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString topEntryString;
+  mDirEntry->ToString(topEntryString);
+
+  for (ULONG node = 0; node < nodeEntries.mNbEntries; ++node) {
+    nsAutoCString dirEntryString;
+    nsAutoCString uri(kOutlookDirectoryScheme);
+    uri.Append(topEntryString);
+    uri.Append('/');
+    nodeEntries.mEntries[node].ToString(dirEntryString);
+    uri.Append(dirEntryString);
+
+    RefPtr<nsAbOutlookDirectory> directory = new nsAbOutlookDirectory;
+
+    // We will later need the URI of the parent directory, so store it here.
+    directory->mParentEntryId = topEntryString;
+    directory->Init(uri.get());
+
+    nsCOMPtr<nsIAbDirectory> dir = do_QueryObject(directory);
+    aNodes->AppendElement(dir);
+  }
+  return rv;
+}
+
+nsresult nsAbOutlookDirectory::commonNotification(
+    nsISupports* aItem, const char* aTopic, const char* aNotificationUID) {
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+
+  // `dirUID` needs to stay in scope until the end of the function.
+  nsAutoCString dirUID;
+  if (!aNotificationUID) {
+    // Use the UID of the directory.
+    GetUID(dirUID);
+    aNotificationUID = dirUID.get();
+  }
+
+  observerService->NotifyObservers(
+      aItem, aTopic, NS_ConvertUTF8toUTF16(aNotificationUID).get());
+  return NS_OK;
+}
+
+nsresult nsAbOutlookDirectory::NotifyItemDeletion(
+    nsISupports* aItem, bool aIsCard, const char* aNotificationUID) {
+  const char* topic;
+  if (aIsCard) {
+    topic = m_IsMailList ? "addrbook-list-member-removed"
+                         : "addrbook-contact-deleted";
+  } else {
+    topic = "addrbook-list-deleted";
+  }
+  return commonNotification(aItem, topic, aNotificationUID);
+}
+
+nsresult nsAbOutlookDirectory::NotifyItemAddition(
+    nsISupports* aItem, bool aIsCard, const char* aNotificationUID) {
+  const char* topic;
+  if (aIsCard) {
+    topic = m_IsMailList ? "addrbook-list-member-added"
+                         : "addrbook-contact-created";
+  } else {
+    topic = "addrbook-list-created";
+  }
+  return commonNotification(aItem, topic, aNotificationUID);
+}
+
+nsresult nsAbOutlookDirectory::NotifyItemModification(
+    nsISupports* aItem, bool aIsCard, const char* aNotificationUID) {
+  return commonNotification(
+      aItem, aIsCard ? "addrbook-contact-updated" : "addrbook-list-updated",
+      aNotificationUID);
+}
+
+nsresult nsAbOutlookDirectory::NotifyCardPropertyChanges(nsIAbCard* aOld,
+                                                         nsIAbCard* aNew) {
+  mozilla::JSONStringWriteFunc<nsCString> jsonString;
+  mozilla::JSONWriter w(jsonString);
+  w.Start();
+  w.StartObjectElement();
+  bool somethingChanged = false;
+  for (uint32_t i = 0; i < sizeof(CardStringProperties) / sizeof(char*); i++) {
+    nsAutoCString oldValue;
+    nsAutoCString newValue;
+    aOld->GetPropertyAsAUTF8String(CardStringProperties[i], oldValue);
+    aNew->GetPropertyAsAUTF8String(CardStringProperties[i], newValue);
+
+    if (!oldValue.Equals(newValue)) {
+      somethingChanged = true;
+      w.StartObjectProperty(mozilla::MakeStringSpan(CardStringProperties[i]));
+      if (oldValue.IsEmpty()) {
+        w.NullProperty("oldValue");
+      } else {
+        w.StringProperty("oldValue", mozilla::MakeStringSpan(oldValue.get()));
+      }
+      if (newValue.IsEmpty()) {
+        w.NullProperty("newValue");
+      } else {
+        w.StringProperty("newValue", mozilla::MakeStringSpan(newValue.get()));
+      }
+      w.EndObject();
+    }
+  }
+
+  for (uint32_t i = 0; i < sizeof(CardIntProperties) / sizeof(char*); i++) {
+    uint32_t oldValue = 0;
+    uint32_t newValue = 0;
+    aOld->GetPropertyAsUint32(CardIntProperties[i], &oldValue);
+    aNew->GetPropertyAsUint32(CardIntProperties[i], &newValue);
+
+    if (oldValue != newValue) {
+      somethingChanged = true;
+      w.StartObjectProperty(mozilla::MakeStringSpan(CardIntProperties[i]));
+      if (oldValue == 0) {
+        w.NullProperty("oldValue");
+      } else {
+        w.IntProperty("oldValue", oldValue);
+      }
+      if (newValue == 0) {
+        w.NullProperty("newValue");
+      } else {
+        w.IntProperty("newValue", newValue);
+      }
+      w.EndObject();
+    }
+  }
+  w.EndObject();
+  w.End();
+
+#if PRINT_TO_CONSOLE
+  printf("%s", jsonString.StringCRef().get());
+#endif
+
+  if (somethingChanged) {
+    nsCOMPtr<nsIObserverService> observerService =
+        mozilla::services::GetObserverService();
+    observerService->NotifyObservers(
+        aNew, "addrbook-contact-properties-updated",
+        NS_ConvertUTF8toUTF16(jsonString.StringCRef()).get());
+  }
+  return NS_OK;
+}
+
+static void UnicodeToWord(const char16_t* aUnicode, WORD& aWord) {
+  aWord = 0;
+  if (aUnicode == nullptr || *aUnicode == 0) {
+    return;
+  }
+  nsresult errorCode = NS_OK;
+  nsAutoString unichar(aUnicode);
+
+  aWord = static_cast<WORD>(unichar.ToInteger(&errorCode));
+  if (NS_FAILED(errorCode)) {
+    PRINTF(("Error conversion string %S: %08x.\n", (wchar_t*)(unichar.get()),
+            errorCode));
+  }
+}
+
+#define PREF_MAIL_ADDR_BOOK_LASTNAMEFIRST "mail.addr_book.lastnamefirst"
+
+NS_IMETHODIMP nsAbOutlookDirectory::ModifyCard(nsIAbCard* aModifiedCard) {
+  return ModifyCardInternal(aModifiedCard, false);
+}
+
+nsresult nsAbOutlookDirectory::ModifyCardInternal(nsIAbCard* aModifiedCard,
+                                                  bool aIsAddition) {
+  NS_ENSURE_ARG_POINTER(aModifiedCard);
+
+  nsString* properties = nullptr;
+  nsAutoString utility;
+  nsAbWinHelperGuard mapiAddBook;
+
+  if (!mapiAddBook->IsOK()) return NS_ERROR_FAILURE;
+
+  nsCString cardEntryString;
+  nsresult retCode = ExtractCardEntry(aModifiedCard, cardEntryString);
+  NS_ENSURE_SUCCESS(retCode, retCode);
+  // If we don't have the card entry, we can't work.
+  if (cardEntryString.IsEmpty()) return NS_ERROR_FAILURE;
+
+  nsMapiEntry cardEntry;
+  cardEntry.Assign(cardEntryString);
+
+  // Get the existing card.
+  nsCString uri;
+  nsCOMPtr<nsIAbCard> oldCard;
+  aModifiedCard->GetPropertyAsAUTF8String("OutlookEntryURI", uri);
+  // If the following fails, we didn't get the old card, not fatal.
+  OutlookCardForURI(uri, getter_AddRefs(oldCard));
+
+  // First, all the standard properties in one go
+  properties = new nsString[index_LastProp];
+  if (!properties) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  aModifiedCard->GetFirstName(properties[index_FirstName]);
+  aModifiedCard->GetLastName(properties[index_LastName]);
+  // This triple search for something to put in the name
+  // is because in the case of a mailing list edition in
+  // Mozilla, the display name will not be provided, and
+  // MAPI doesn't allow that, so we fall back on an optional
+  // name, and when all fails, on the email address.
+  aModifiedCard->GetDisplayName(properties[index_DisplayName]);
+  if (properties[index_DisplayName].IsEmpty()) {
+    nsresult rv;
+    nsCOMPtr<nsIPrefBranch> prefBranch =
+        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    int32_t format;
+    rv = prefBranch->GetIntPref(PREF_MAIL_ADDR_BOOK_LASTNAMEFIRST, &format);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = aModifiedCard->GenerateName(format, nullptr,
+                                     properties[index_DisplayName]);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (properties[index_DisplayName].IsEmpty()) {
+      aModifiedCard->GetPrimaryEmail(properties[index_DisplayName]);
+    }
+  }
+
+  nsMapiEntry dirEntry;
+  if (m_IsMailList) {
+    nsAutoCString uri(mURI);
+    // Trim off the mailing list entry ID from the mailing list URI
+    // to get the top-level directory entry ID.
+    nsAutoCString topEntryString;
+    int32_t slashPos = uri.RFindChar('/');
+    uri.SetLength(slashPos);
+    makeEntryIdFromURI(kOutlookDirectoryScheme, uri.get(), topEntryString);
+    dirEntry.Assign(topEntryString);
+  } else {
+    dirEntry.Assign(mDirEntry->mByteCount, mDirEntry->mEntryId);
+  }
+
+  aModifiedCard->SetDisplayName(properties[index_DisplayName]);
+  aModifiedCard->GetPropertyAsAString(kNicknameProperty,
+                                      properties[index_NickName]);
+  aModifiedCard->GetPropertyAsAString(kWorkPhoneProperty,
+                                      properties[index_WorkPhoneNumber]);
+  aModifiedCard->GetPropertyAsAString(kHomePhoneProperty,
+                                      properties[index_HomePhoneNumber]);
+  aModifiedCard->GetPropertyAsAString(kFaxProperty,
+                                      properties[index_WorkFaxNumber]);
+  aModifiedCard->GetPropertyAsAString(kPagerProperty,
+                                      properties[index_PagerNumber]);
+  aModifiedCard->GetPropertyAsAString(kCellularProperty,
+                                      properties[index_MobileNumber]);
+  aModifiedCard->GetPropertyAsAString(kHomeCityProperty,
+                                      properties[index_HomeCity]);
+  aModifiedCard->GetPropertyAsAString(kHomeStateProperty,
+                                      properties[index_HomeState]);
+  aModifiedCard->GetPropertyAsAString(kHomeZipCodeProperty,
+                                      properties[index_HomeZip]);
+  aModifiedCard->GetPropertyAsAString(kHomeCountryProperty,
+                                      properties[index_HomeCountry]);
+  aModifiedCard->GetPropertyAsAString(kWorkCityProperty,
+                                      properties[index_WorkCity]);
+  aModifiedCard->GetPropertyAsAString(kWorkStateProperty,
+                                      properties[index_WorkState]);
+  aModifiedCard->GetPropertyAsAString(kWorkZipCodeProperty,
+                                      properties[index_WorkZip]);
+  aModifiedCard->GetPropertyAsAString(kWorkCountryProperty,
+                                      properties[index_WorkCountry]);
+  aModifiedCard->GetPropertyAsAString(kJobTitleProperty,
+                                      properties[index_JobTitle]);
+  aModifiedCard->GetPropertyAsAString(kDepartmentProperty,
+                                      properties[index_Department]);
+  aModifiedCard->GetPropertyAsAString(kCompanyProperty,
+                                      properties[index_Company]);
+  aModifiedCard->GetPropertyAsAString(kWorkWebPageProperty,
+                                      properties[index_WorkWebPage]);
+  aModifiedCard->GetPropertyAsAString(kHomeWebPageProperty,
+                                      properties[index_HomeWebPage]);
+  aModifiedCard->GetPropertyAsAString(kNotesProperty, properties[index_Notes]);
+  if (!mapiAddBook->SetPropertiesUString(dirEntry, cardEntry,
+                                         OutlookCardMAPIProps, index_LastProp,
+                                         properties)) {
+    PRINTF(("Cannot set general properties.\n"));
+  }
+
+  delete[] properties;
+  nsString unichar;
+  nsString unichar2;
+  WORD year = 0;
+  WORD month = 0;
+  WORD day = 0;
+
+  aModifiedCard->GetPrimaryEmail(unichar);
+  if (!mapiAddBook->SetPropertyUString(cardEntry, PR_EMAIL_ADDRESS_W,
+                                       unichar.get())) {
+    PRINTF(("Cannot set primary email.\n"));
+  }
+  aModifiedCard->GetPropertyAsAString(kHomeAddressProperty, unichar);
+  aModifiedCard->GetPropertyAsAString(kHomeAddress2Property, unichar2);
+
+  utility.Assign(unichar.get());
+  if (!utility.IsEmpty()) utility.AppendLiteral("\r\n");
+
+  utility.Append(unichar2.get());
+  if (!mapiAddBook->SetPropertyUString(cardEntry, PR_HOME_ADDRESS_STREET_W,
+                                       utility.get())) {
+    PRINTF(("Cannot set home address.\n"));
+  }
+
+  unichar.Truncate();
+  aModifiedCard->GetPropertyAsAString(kWorkAddressProperty, unichar);
+  unichar2.Truncate();
+  aModifiedCard->GetPropertyAsAString(kWorkAddress2Property, unichar2);
+
+  utility.Assign(unichar.get());
+  if (!utility.IsEmpty()) utility.AppendLiteral("\r\n");
+
+  utility.Append(unichar2.get());
+  if (!mapiAddBook->SetPropertyUString(cardEntry, PR_BUSINESS_ADDRESS_STREET_W,
+                                       utility.get())) {
+    PRINTF(("Cannot set work address.\n"));
+  }
+
+  unichar.Truncate();
+  aModifiedCard->GetPropertyAsAString(kBirthYearProperty, unichar);
+  UnicodeToWord(unichar.get(), year);
+  unichar.Truncate();
+  aModifiedCard->GetPropertyAsAString(kBirthMonthProperty, unichar);
+  UnicodeToWord(unichar.get(), month);
+  unichar.Truncate();
+  aModifiedCard->GetPropertyAsAString(kBirthDayProperty, unichar);
+  UnicodeToWord(unichar.get(), day);
+  if (!mapiAddBook->SetPropertyDate(dirEntry, cardEntry, true, PR_BIRTHDAY,
+                                    year, month, day)) {
+    PRINTF(("Cannot set date.\n"));
+  }
+
+  if (!aIsAddition) {
+    NotifyItemModification(aModifiedCard, true);
+    if (oldCard) NotifyCardPropertyChanges(oldCard, aModifiedCard);
+  }
+
+  return retCode;
+}
+
+static void splitString(nsString& aSource, nsString& aTarget) {
+  aTarget.Truncate();
+  int32_t offset = aSource.FindChar('\n');
+
+  if (offset >= 0) {
+    const char16_t* source = aSource.get() + offset + 1;
+    while (*source) {
+      if (*source == '\n' || *source == '\r')
+        aTarget.Append(char16_t(' '));
+      else
+        aTarget.Append(*source);
+      ++source;
+    }
+    int32_t offsetCR = aSource.FindChar('\r');
+    aSource.SetLength(offsetCR >= 0 ? offsetCR : offset);
+  }
+}
+
+nsresult nsAbOutlookDirectory::OutlookCardForURI(const nsACString& aUri,
+                                                 nsIAbCard** newCard) {
+  NS_ENSURE_ARG_POINTER(newCard);
+
+  nsAutoCString cardEntryString;
+  makeEntryIdFromURI(kOutlookCardScheme, PromiseFlatCString(aUri).get(),
+                     cardEntryString);
+
+  nsAbWinHelperGuard mapiAddBook;
+  if (!mapiAddBook->IsOK()) return NS_ERROR_FAILURE;
+
+  nsresult rv;
+  nsCOMPtr<nsIAbCard> card =
+      do_CreateInstance("@mozilla.org/addressbook/cardproperty;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  card->SetPropertyAsAUTF8String("OutlookEntryURI", aUri);
+
+  nsMapiEntry cardEntry;
+  cardEntry.Assign(cardEntryString);
+
+  nsString unichars[index_LastProp];
+  bool success[index_LastProp];
+
+  nsMapiEntry dirEntry;
+  if (m_IsMailList) {
+    nsAutoCString uri(mURI);
+    // Trim off the mailing list entry ID from the mailing list URI
+    // to get the top-level directory entry ID.
+    nsAutoCString topEntryString;
+    int32_t slashPos = uri.RFindChar('/');
+    uri.SetLength(slashPos);
+    makeEntryIdFromURI(kOutlookDirectoryScheme, uri.get(), topEntryString);
+    dirEntry.Assign(topEntryString);
+  } else {
+    dirEntry.Assign(mDirEntry->mByteCount, mDirEntry->mEntryId);
+  }
+
+  if (mapiAddBook->GetPropertiesUString(dirEntry, cardEntry,
+                                        OutlookCardMAPIProps, index_LastProp,
+                                        unichars, success)) {
+    if (success[index_FirstName]) card->SetFirstName(unichars[index_FirstName]);
+    if (success[index_LastName]) card->SetLastName(unichars[index_LastName]);
+    if (success[index_DisplayName])
+      card->SetDisplayName(unichars[index_DisplayName]);
+
+#define SETPROP(name, index) \
+  if (success[index]) card->SetPropertyAsAString(name, unichars[index])
+    SETPROP(kNicknameProperty, index_NickName);
+    SETPROP(kWorkPhoneProperty, index_WorkPhoneNumber);
+    SETPROP(kHomePhoneProperty, index_HomePhoneNumber);
+    SETPROP(kFaxProperty, index_WorkFaxNumber);
+    SETPROP(kPagerProperty, index_PagerNumber);
+    SETPROP(kCellularProperty, index_MobileNumber);
+    SETPROP(kHomeCityProperty, index_HomeCity);
+    SETPROP(kHomeStateProperty, index_HomeState);
+    SETPROP(kHomeZipCodeProperty, index_HomeZip);
+    SETPROP(kHomeCountryProperty, index_HomeCountry);
+    SETPROP(kWorkCityProperty, index_WorkCity);
+    SETPROP(kWorkStateProperty, index_WorkState);
+    SETPROP(kWorkZipCodeProperty, index_WorkZip);
+    SETPROP(kWorkCountryProperty, index_WorkCountry);
+    SETPROP(kJobTitleProperty, index_JobTitle);
+    SETPROP(kDepartmentProperty, index_Department);
+    SETPROP(kCompanyProperty, index_Company);
+    SETPROP(kWorkWebPageProperty, index_WorkWebPage);
+    SETPROP(kHomeWebPageProperty, index_HomeWebPage);
+    SETPROP(kNotesProperty, index_Notes);
+  }
+
+  ULONG cardType = 0;
+  if (mapiAddBook->GetPropertyLong(cardEntry, PR_OBJECT_TYPE, cardType)) {
+    card->SetIsMailList(cardType == MAPI_DISTLIST);
+    if (cardType == MAPI_DISTLIST) {
+      nsCString dirEntryString;
+      mDirEntry->ToString(dirEntryString);
+      nsAutoCString uri(kOutlookDirectoryScheme);
+      uri.Append(dirEntryString);
+      uri.Append('/');
+      nsCString originalUID;
+      AlignListEntryStringAndGetUID(cardEntryString, originalUID);
+      uri.Append(cardEntryString);
+      card->SetMailListURI(uri.get());
+      if (!originalUID.IsEmpty()) card->SetUID(originalUID);
+
+      // In case the display is by "First Last" or "Last, First", give the card
+      // a name, otherwise nothing is displayed.
+      if (success[index_DisplayName])
+        card->SetLastName(unichars[index_DisplayName]);
+    }
+  }
+
+  nsAutoString unichar;
+  nsAutoString unicharBis;
+  if (mapiAddBook->GetPropertyUString(cardEntry, PR_EMAIL_ADDRESS_W, unichar)) {
+    card->SetPrimaryEmail(unichar);
+  }
+  if (mapiAddBook->GetPropertyUString(cardEntry, PR_HOME_ADDRESS_STREET_W,
+                                      unichar)) {
+    splitString(unichar, unicharBis);
+    card->SetPropertyAsAString(kHomeAddressProperty, unichar);
+    card->SetPropertyAsAString(kHomeAddress2Property, unicharBis);
+  }
+  if (mapiAddBook->GetPropertyUString(cardEntry, PR_BUSINESS_ADDRESS_STREET_W,
+                                      unichar)) {
+    splitString(unichar, unicharBis);
+    card->SetPropertyAsAString(kWorkAddressProperty, unichar);
+    card->SetPropertyAsAString(kWorkAddress2Property, unicharBis);
+  }
+
+  WORD year = 0, month = 0, day = 0;
+  if (mapiAddBook->GetPropertyDate(dirEntry, cardEntry, true, PR_BIRTHDAY, year,
+                                   month, day)) {
+    card->SetPropertyAsUint32(kBirthYearProperty, year);
+    card->SetPropertyAsUint32(kBirthMonthProperty, month);
+    card->SetPropertyAsUint32(kBirthDayProperty, day);
+  }
+
+  card.forget(newCard);
+  return NS_OK;
+}
+
+void nsAbOutlookDirectory::AlignListEntryStringAndGetUID(
+    nsCString& aEntryString, nsCString& aOriginalUID) {
+  // Sadly when scanning for cards and finding a distribution list, the
+  // entry ID is different to the entry ID returned when scanning the top level
+  // directory for distribution lists. We make the adjustment here.
+  // We also retrieve the original UID from the mailing list.
+  nsAbWinHelperGuard mapiAddBook;
+  if (!mapiAddBook->IsOK()) return;
+
+  uint32_t nbLists = 0;
+  nsresult rv = m_AddressList->GetLength(&nbLists);
+  NS_ENSURE_SUCCESS_VOID(rv);
+  for (uint32_t i = 0; i < nbLists; i++) {
+    nsCOMPtr<nsIAbDirectory> list = do_QueryElementAt(m_AddressList, i, &rv);
+    NS_ENSURE_SUCCESS_VOID(rv);
+
+    // Get URI and extract entry ID.
+    nsAutoCString listURI;
+    list->GetURI(listURI);
+    int ind = listURI.RFindChar('/');
+    listURI = Substring(listURI, ind + 1);
+
+    if (aEntryString.Equals(listURI)) {
+      list->GetUID(aOriginalUID);
+      return;
+    }
+    if (mapiAddBook->CompareEntryIDs(aEntryString, listURI)) {
+      PRINTF(("Entry ID for mailing list replaced:\nWas: %s\nNow: %s\n",
+              aEntryString.get(), listURI.get()));
+      aEntryString = listURI;
+      list->GetUID(aOriginalUID);
+      return;
+    }
+  }
+  PRINTF(("Entry ID for mailing list not found.\n"));
+}