Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
/*
Outlook mail import
*/
#include "nsCOMPtr.h"
#include "nscore.h"
#include "nsMsgUtils.h"
#include "nsIImportService.h"
#include "nsIImportFieldMap.h"
#include "nsIImportMailboxDescriptor.h"
#include "nsIImportABDescriptor.h"
#include "nsOutlookStringBundle.h"
#include "nsIAbCard.h"
#include "mdb.h"
#include "ImportDebug.h"
#include "nsOutlookMail.h"
#include "nsUnicharUtils.h"
#include "nsIOutputStream.h"
#include "nsIMsgPluggableStore.h"
#include "nsIMsgHdr.h"
#include "nsIMsgFolder.h"
#include "nsMsgI18N.h"
#include "nsNetUtil.h"
/* ------------ Address book stuff ----------------- */
typedef struct {
int32_t mozField;
int32_t multiLine;
ULONG mapiTag;
} MAPIFields;
/*
Fields in MAPI, not in Mozilla
PR_OFFICE_LOCATION
FIX - PR_BIRTHDAY - stored as PT_SYSTIME - FIX to extract for moz address book
birthday PR_DISPLAY_NAME_PREFIX - Mr., Mrs. Dr., etc. PR_SPOUSE_NAME PR_GENDER
- integer, not text FIX - PR_CONTACT_EMAIL_ADDRESSES - multiuline strings for
email addresses, needs parsing to get secondary email address for mozilla
*/
#define kIsMultiLine -2
#define kNoMultiLine -1
static MAPIFields gMapiFields[] = {
{35, kIsMultiLine, PR_BODY},
{6, kNoMultiLine, PR_BUSINESS_TELEPHONE_NUMBER},
{7, kNoMultiLine, PR_HOME_TELEPHONE_NUMBER},
{25, kNoMultiLine, PR_COMPANY_NAME},
{23, kNoMultiLine, PR_TITLE},
{10, kNoMultiLine, PR_CELLULAR_TELEPHONE_NUMBER},
{9, kNoMultiLine, PR_PAGER_TELEPHONE_NUMBER},
{8, kNoMultiLine, PR_BUSINESS_FAX_NUMBER},
{8, kNoMultiLine, PR_HOME_FAX_NUMBER},
{22, kNoMultiLine, PR_COUNTRY},
{19, kNoMultiLine, PR_LOCALITY},
{20, kNoMultiLine, PR_STATE_OR_PROVINCE},
{17, 18, PR_STREET_ADDRESS},
{21, kNoMultiLine, PR_POSTAL_CODE},
{27, kNoMultiLine, PR_PERSONAL_HOME_PAGE},
{26, kNoMultiLine, PR_BUSINESS_HOME_PAGE},
{13, kNoMultiLine, PR_HOME_ADDRESS_CITY},
{16, kNoMultiLine, PR_HOME_ADDRESS_COUNTRY},
{15, kNoMultiLine, PR_HOME_ADDRESS_POSTAL_CODE},
{14, kNoMultiLine, PR_HOME_ADDRESS_STATE_OR_PROVINCE},
{11, 12, PR_HOME_ADDRESS_STREET},
{24, kNoMultiLine, PR_DEPARTMENT_NAME}};
/* ---------------------------------------------------- */
#define kCopyBufferSize (16 * 1024)
// The email address in Outlook Contacts doesn't have a named
// property, we need to use this mapi name ID to access the email
// The MAPINAMEID for email address has ulKind=MNID_ID
// Outlook stores each email address in two IDs, 32899/32900 for Email1
// 32915/32916 for Email2, 32931/32932 for Email3
// Current we use OUTLOOK_EMAIL1_MAPI_ID1 for primary email
// OUTLOOK_EMAIL2_MAPI_ID1 for secondary email
#define OUTLOOK_EMAIL1_MAPI_ID1 32899
#define OUTLOOK_EMAIL1_MAPI_ID2 32900
#define OUTLOOK_EMAIL2_MAPI_ID1 32915
#define OUTLOOK_EMAIL2_MAPI_ID2 32916
#define OUTLOOK_EMAIL3_MAPI_ID1 32931
#define OUTLOOK_EMAIL3_MAPI_ID2 32932
nsOutlookMail::nsOutlookMail() {
m_gotAddresses = false;
m_gotFolders = false;
m_haveMapi = CMapiApi::LoadMapi();
m_lpMdb = NULL;
}
nsOutlookMail::~nsOutlookMail() {
// EmptyAttachments();
}
nsresult nsOutlookMail::GetMailFolders(
nsTArray<RefPtr<nsIImportMailboxDescriptor>>& boxes) {
if (!m_haveMapi) {
IMPORT_LOG0("GetMailFolders called before Mapi is initialized\n");
return NS_ERROR_FAILURE;
}
nsresult rv;
boxes.Clear();
nsCOMPtr<nsIImportService> impSvc(
do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
if (NS_FAILED(rv)) return rv;
m_gotFolders = true;
m_folderList.ClearAll();
m_mapi.Initialize();
m_mapi.LogOn();
if (m_storeList.GetSize() == 0) m_mapi.IterateStores(m_storeList);
int i = 0;
CMapiFolder* pFolder;
if (m_storeList.GetSize() > 1) {
while ((pFolder = m_storeList.GetItem(i))) {
CMapiFolder* pItem = new CMapiFolder(pFolder);
pItem->SetDepth(1);
m_folderList.AddItem(pItem);
if (!m_mapi.GetStoreFolders(pItem->GetCBEntryID(), pItem->GetEntryID(),
m_folderList, 2)) {
IMPORT_LOG1("GetStoreFolders for index %d failed.\n", i);
}
i++;
}
} else {
if ((pFolder = m_storeList.GetItem(i))) {
if (!m_mapi.GetStoreFolders(pFolder->GetCBEntryID(),
pFolder->GetEntryID(), m_folderList, 1)) {
IMPORT_LOG1("GetStoreFolders for index %d failed.\n", i);
}
}
}
// Create the mailbox descriptors for the list of folders
nsCOMPtr<nsIImportMailboxDescriptor> pID;
nsString name;
nsString uniName;
for (i = 0; i < m_folderList.GetSize(); i++) {
pFolder = m_folderList.GetItem(i);
rv = impSvc->CreateNewMailboxDescriptor(getter_AddRefs(pID));
if (NS_SUCCEEDED(rv)) {
pID->SetDepth(pFolder->GetDepth());
pID->SetIdentifier(i);
pFolder->GetDisplayName(name);
pID->SetDisplayName(name.get());
pID->SetSize(1000);
boxes.AppendElement(pID);
}
}
return NS_OK;
}
bool nsOutlookMail::IsAddressBookNameUnique(nsString& name, nsString& list) {
nsString usedName;
usedName.Append('[');
usedName.Append(name);
usedName.AppendLiteral("],");
return list.Find(usedName) == -1;
}
void nsOutlookMail::MakeAddressBookNameUnique(nsString& name, nsString& list) {
nsString newName;
int idx = 1;
newName = name;
while (!IsAddressBookNameUnique(newName, list)) {
newName = name;
newName.Append(char16_t(' '));
newName.AppendInt((int32_t)idx);
idx++;
}
name = newName;
list.Append('[');
list.Append(name);
list.AppendLiteral("],");
}
nsresult nsOutlookMail::GetAddressBooks(
nsTArray<RefPtr<nsIImportABDescriptor>>& books) {
books.Clear();
if (!m_haveMapi) {
IMPORT_LOG0("GetAddressBooks called before Mapi is initialized\n");
return NS_ERROR_FAILURE;
}
nsresult rv;
nsCOMPtr<nsIImportService> impSvc(
do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
if (NS_FAILED(rv)) return rv;
m_gotAddresses = true;
m_addressList.ClearAll();
m_mapi.Initialize();
m_mapi.LogOn();
if (m_storeList.GetSize() == 0) m_mapi.IterateStores(m_storeList);
int i = 0;
CMapiFolder* pFolder;
if (m_storeList.GetSize() > 1) {
while ((pFolder = m_storeList.GetItem(i))) {
CMapiFolder* pItem = new CMapiFolder(pFolder);
pItem->SetDepth(1);
m_addressList.AddItem(pItem);
if (!m_mapi.GetStoreAddressFolders(pItem->GetCBEntryID(),
pItem->GetEntryID(), m_addressList)) {
IMPORT_LOG1("GetStoreAddressFolders for index %d failed.\n", i);
}
i++;
}
} else {
if ((pFolder = m_storeList.GetItem(i))) {
if (!m_mapi.GetStoreAddressFolders(
pFolder->GetCBEntryID(), pFolder->GetEntryID(), m_addressList)) {
IMPORT_LOG1("GetStoreFolders for index %d failed.\n", i);
}
}
}
// Create the mailbox descriptors for the list of folders
nsCOMPtr<nsIImportABDescriptor> pID;
nsString name;
nsString list;
for (i = 0; i < m_addressList.GetSize(); i++) {
pFolder = m_addressList.GetItem(i);
if (!pFolder->IsStore()) {
rv = impSvc->CreateNewABDescriptor(getter_AddRefs(pID));
if (NS_SUCCEEDED(rv)) {
pID->SetIdentifier(i);
pFolder->GetDisplayName(name);
MakeAddressBookNameUnique(name, list);
pID->SetPreferredName(name);
pID->SetSize(100);
books.AppendElement(pID);
}
}
}
return NS_OK;
}
void nsOutlookMail::OpenMessageStore(CMapiFolder* pNextFolder) {
// Open the store specified
if (pNextFolder->IsStore()) {
if (!m_mapi.OpenStore(pNextFolder->GetCBEntryID(),
pNextFolder->GetEntryID(), &m_lpMdb)) {
m_lpMdb = NULL;
IMPORT_LOG0("CMapiApi::OpenStore failed\n");
}
return;
}
// Check to see if we should open the one and only store
if (!m_lpMdb) {
if (m_storeList.GetSize() == 1) {
CMapiFolder* pFolder = m_storeList.GetItem(0);
if (pFolder) {
if (!m_mapi.OpenStore(pFolder->GetCBEntryID(), pFolder->GetEntryID(),
&m_lpMdb)) {
m_lpMdb = NULL;
IMPORT_LOG0("CMapiApi::OpenStore failed\n");
}
} else {
IMPORT_LOG0("Error retrieving the one & only message store\n");
}
} else {
IMPORT_LOG0(
"*** Error importing a folder without a valid message store\n");
}
}
}
// Roles and responsibilities:
// nsOutlookMail
// - Connect to Outlook
// - Enumerate the mailboxes
// - Iterate the mailboxes
// - For each mail, create one nsOutlookCompose object
// - For each mail, create one CMapiMessage object
//
// nsOutlookCompose
// - Establish a TB session
// - Connect to all required services
// - Perform the composition of the RC822 document from the data gathered by
// CMapiMessage
// - Save the composed message to the TB mailbox
// - Ensure the proper cleanup
//
// CMapiMessage
// - Encapsulate the MAPI message interface
// - Gather the information required to (re)compose the message
ImportMailboxRunnable::ImportMailboxRunnable(
uint32_t* pDoneSoFar, bool* pAbort, int32_t index, const char16_t* pName,
nsIMsgFolder* dstFolder, int32_t* pMsgCount, nsOutlookMail* aCaller)
: mozilla::Runnable("ImportMailboxRunnable"),
mResult(NS_OK),
mCaller(aCaller),
mDoneSoFar(pDoneSoFar),
mAbort(pAbort),
mIndex(index),
mName(pName),
mDstFolder(dstFolder),
mMsgCount(pMsgCount) {}
NS_IMETHODIMP ImportMailboxRunnable::Run() {
if ((mIndex < 0) || (mIndex >= mCaller->m_folderList.GetSize())) {
IMPORT_LOG0("*** Bad mailbox identifier, unable to import\n");
*mAbort = true;
mResult = NS_ERROR_FAILURE;
return NS_OK; // Sync runnable must return OK.
}
int32_t dummyMsgCount = 0;
if (mMsgCount)
*mMsgCount = 0;
else
mMsgCount = &dummyMsgCount;
CMapiFolder* pFolder = mCaller->m_folderList.GetItem(mIndex);
mCaller->OpenMessageStore(pFolder);
if (!mCaller->m_lpMdb) {
IMPORT_LOG1("*** Unable to obtain mapi message store for mailbox: %S\n",
(const wchar_t*)mName);
mResult = NS_ERROR_FAILURE;
return NS_OK; // Sync runnable must return OK.
}
if (pFolder->IsStore()) return NS_OK;
// now what?
CMapiFolderContents contents(mCaller->m_lpMdb, pFolder->GetCBEntryID(),
pFolder->GetEntryID());
BOOL done = FALSE;
ULONG cbEid;
LPENTRYID lpEid;
ULONG oType;
LPMESSAGE lpMsg = nullptr;
ULONG totalCount;
double doneCalc;
nsCOMPtr<nsIOutputStream> outputStream;
nsCOMPtr<nsIMsgPluggableStore> msgStore;
nsresult rv = mDstFolder->GetMsgStore(getter_AddRefs(msgStore));
NS_ENSURE_SUCCESS(rv, rv);
while (!done) {
if (!contents.GetNext(&cbEid, &lpEid, &oType, &done)) {
IMPORT_LOG1("*** Error iterating mailbox: %S\n", (const wchar_t*)mName);
mResult = NS_ERROR_FAILURE;
return NS_OK; // Sync runnable must return OK.
}
nsCOMPtr<nsIMsgDBHdr> msgHdr;
rv = msgStore->GetNewMsgOutputStream(mDstFolder, getter_AddRefs(msgHdr),
getter_AddRefs(outputStream));
if (NS_FAILED(rv)) {
IMPORT_LOG1("*** Error getting nsIOutputStream of mailbox: %S\n",
(const wchar_t*)mName);
mResult = rv;
return NS_OK; // Sync runnable must return OK.
}
totalCount = contents.GetCount();
doneCalc = *mMsgCount;
doneCalc /= totalCount;
doneCalc *= 1000;
if (mDoneSoFar) {
*mDoneSoFar = (uint32_t)doneCalc;
if (*mDoneSoFar > 1000) *mDoneSoFar = 1000;
}
if (!done && (oType == MAPI_MESSAGE)) {
if (!mCaller->m_mapi.OpenMdbEntry(mCaller->m_lpMdb, cbEid, lpEid,
(LPUNKNOWN*)&lpMsg)) {
IMPORT_LOG1("*** Error opening messages in mailbox: %S\n",
(const wchar_t*)mName);
mResult = NS_ERROR_FAILURE;
return NS_OK; // Sync runnable must return OK.
}
// See if it's a drafts folder. Outlook doesn't allow drafts
// folder to be configured so it's ok to hard code it here.
nsAutoString folderName(mName);
nsMsgDeliverMode mode = nsIMsgSend::nsMsgDeliverNow;
mode = nsIMsgSend::nsMsgSaveAsDraft;
if (folderName.LowerCaseEqualsLiteral("drafts"))
mode = nsIMsgSend::nsMsgSaveAsDraft;
rv = ImportMessage(lpMsg, outputStream, mode);
if (NS_SUCCEEDED(rv)) { // No errors & really imported
(*mMsgCount)++;
msgStore->FinishNewMessage(outputStream, msgHdr);
outputStream = nullptr;
} else {
IMPORT_LOG1("*** Error reading message from mailbox: %S\n",
(const wchar_t*)mName);
msgStore->DiscardNewMessage(outputStream, msgHdr);
outputStream = nullptr;
}
}
}
return NS_OK;
}
nsresult ProxyImportMailbox(uint32_t* pDoneSoFar, bool* pAbort, int32_t index,
const char16_t* pName, nsIMsgFolder* dstFolder,
int32_t* pMsgCount, nsOutlookMail* aCaller) {
RefPtr<ImportMailboxRunnable> importMailbox = new ImportMailboxRunnable(
pDoneSoFar, pAbort, index, pName, dstFolder, pMsgCount, aCaller);
nsresult rv = NS_DispatchAndSpinEventLoopUntilComplete(
"ProxyImportMailbox"_ns, mozilla::GetMainThreadSerialEventTarget(),
do_AddRef(importMailbox));
NS_ENSURE_SUCCESS(rv, rv);
return importMailbox->mResult;
}
nsresult nsOutlookMail::ImportMailbox(uint32_t* pDoneSoFar, bool* pAbort,
int32_t index, const char16_t* pName,
nsIMsgFolder* dstFolder,
int32_t* pMsgCount) {
return ProxyImportMailbox(pDoneSoFar, pAbort, index, pName, dstFolder,
pMsgCount, this);
}
nsresult ImportMailboxRunnable::ImportMessage(LPMESSAGE lpMsg,
nsIOutputStream* pDest,
nsMsgDeliverMode mode) {
CMapiMessage msg(lpMsg);
// If we wanted to skip messages that were downloaded in header only mode, we
// would return NS_ERROR_FAILURE if !msg.FullMessageDownloaded. However, we
// don't do this because it may cause seemingly wrong import results.
// A user will get less mails in his imported folder than were in the original
// folder, and this may make user feel like TB import is bad. In reality, the
// skipped messages are those that have not been downloaded yet, because they
// were downloaded in the "headers-only" mode. This is different from the case
// when the message is downloaded completely, but consists only of headers -
// in this case the message will be imported anyway.
if (!msg.ValidState()) return NS_ERROR_FAILURE;
// I have to create a composer for each message, since it turns out that if we
// create one composer for several messages, the Send Proxy object that is
// shared between those messages isn't reset properly (at least in the current
// implementation), which leads to crash. If there's a proper way to
// reinitialize the Send Proxy object, then we could slightly optimize the
// send process.
nsOutlookCompose compose;
nsresult rv = compose.ProcessMessage(mode, msg, pDest);
// Just for YUCKS, let's try an extra endline
nsOutlookMail::WriteData(pDest, "\x0D\x0A", 2);
return rv;
}
BOOL nsOutlookMail::WriteData(nsIOutputStream* pDest, const char* pData,
uint32_t len) {
uint32_t written;
nsresult rv = pDest->Write(pData, len, &written);
return NS_SUCCEEDED(rv) && written == len;
}
nsresult nsOutlookMail::ImportAddresses(uint32_t* pCount, uint32_t* pTotal,
const char16_t* pName, uint32_t id,
nsIAbDirectory* pDirectory,
nsString& errors) {
if (id >= (uint32_t)(m_addressList.GetSize())) {
IMPORT_LOG0("*** Bad address identifier, unable to import\n");
return NS_ERROR_FAILURE;
}
uint32_t dummyCount = 0;
if (pCount)
*pCount = 0;
else
pCount = &dummyCount;
CMapiFolder* pFolder;
if (id > 0) {
int32_t idx = (int32_t)id;
idx--;
while (idx >= 0) {
pFolder = m_addressList.GetItem(idx);
if (pFolder->IsStore()) {
OpenMessageStore(pFolder);
break;
}
idx--;
}
}
pFolder = m_addressList.GetItem(id);
OpenMessageStore(pFolder);
if (!m_lpMdb) {
IMPORT_LOG1(
"*** Unable to obtain mapi message store for address book: %S\n",
(const wchar_t*)pName);
return NS_ERROR_FAILURE;
}
if (pFolder->IsStore()) return NS_OK;
nsresult rv;
nsCOMPtr<nsIImportFieldMap> pFieldMap;
nsCOMPtr<nsIImportService> impSvc(
do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
if (NS_SUCCEEDED(rv)) {
rv = impSvc->CreateNewFieldMap(getter_AddRefs(pFieldMap));
}
CMapiFolderContents contents(m_lpMdb, pFolder->GetCBEntryID(),
pFolder->GetEntryID());
BOOL done = FALSE;
ULONG cbEid;
LPENTRYID lpEid;
ULONG oType;
LPMESSAGE lpMsg;
nsCString type;
LPSPropValue pVal;
nsString subject;
while (!done) {
(*pCount)++;
if (!contents.GetNext(&cbEid, &lpEid, &oType, &done)) {
IMPORT_LOG1("*** Error iterating address book: %S\n",
(const wchar_t*)pName);
return NS_ERROR_FAILURE;
}
if (pTotal && (*pTotal == 0)) *pTotal = contents.GetCount();
if (!done && (oType == MAPI_MESSAGE)) {
if (!m_mapi.OpenMdbEntry(m_lpMdb, cbEid, lpEid, (LPUNKNOWN*)&lpMsg)) {
IMPORT_LOG1("*** Error opening messages in mailbox: %S\n",
(const wchar_t*)pName);
return NS_ERROR_FAILURE;
}
// Get the PR_MESSAGE_CLASS attribute,
// ensure that it is IPM.Contact
pVal = m_mapi.GetMapiProperty(lpMsg, PR_MESSAGE_CLASS);
if (pVal) {
type.Truncate();
m_mapi.GetStringFromProp(pVal, type);
if (type.EqualsLiteral("IPM.Contact")) {
// This is a contact, add it to the address book!
subject.Truncate();
pVal = m_mapi.GetMapiProperty(lpMsg, PR_SUBJECT);
if (pVal) m_mapi.GetStringFromProp(pVal, subject);
nsCOMPtr<nsIAbCard> newCard =
do_CreateInstance("@mozilla.org/addressbook/cardproperty;1", &rv);
if (newCard) {
if (BuildCard(subject.get(), pDirectory, newCard, lpMsg,
pFieldMap)) {
nsIAbCard* outCard;
pDirectory->AddCard(newCard, &outCard);
}
}
} else if (type.EqualsLiteral("IPM.DistList")) {
// This is a list/group, add it to the address book!
subject.Truncate();
pVal = m_mapi.GetMapiProperty(lpMsg, PR_SUBJECT);
if (pVal) m_mapi.GetStringFromProp(pVal, subject);
CreateList(subject, pDirectory, lpMsg, pFieldMap);
}
}
lpMsg->Release();
}
}
return rv;
}
nsresult nsOutlookMail::CreateList(const nsString& pName,
nsIAbDirectory* pDirectory,
LPMAPIPROP pUserList,
nsIImportFieldMap* pFieldMap) {
// If no name provided then we're done.
if (pName.IsEmpty()) return NS_OK;
nsresult rv = NS_ERROR_FAILURE;
// Make sure we have db to work with.
if (!pDirectory) return rv;
nsCOMPtr<nsIAbDirectory> newList =
do_CreateInstance("@mozilla.org/addressbook/directoryproperty;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = newList->SetDirName(pName);
NS_ENSURE_SUCCESS(rv, rv);
HRESULT hr;
LPSPropValue value = NULL;
ULONG valueCount = 0;
LPSPropTagArray properties = NULL;
m_mapi.MAPIAllocateBuffer(CbNewSPropTagArray(1), (void**)&properties);
properties->cValues = 1;
properties->aulPropTag[0] = m_mapi.GetEmailPropertyTag(pUserList, 0x8054);
hr = pUserList->GetProps(properties, 0, &valueCount, &value);
m_mapi.MAPIFreeBuffer(properties);
if (HR_FAILED(hr)) return NS_ERROR_FAILURE;
if (!value) return NS_ERROR_NOT_AVAILABLE;
// XXX from here out, value must be freed with MAPIFreeBuffer
SBinaryArray* sa = (SBinaryArray*)&value->Value.bin;
if (!sa || !sa->lpbin) {
m_mapi.MAPIFreeBuffer(value);
return NS_ERROR_NULL_POINTER;
}
LPENTRYID lpEid;
ULONG cbEid;
ULONG idx;
LPMESSAGE lpMsg;
nsCString type;
LPSPropValue pVal;
nsString subject;
ULONG total;
total = sa->cValues;
for (idx = 0; idx < total; idx++) {
lpEid = (LPENTRYID)sa->lpbin[idx].lpb;
cbEid = sa->lpbin[idx].cb;
if (!m_mapi.OpenEntry(cbEid, lpEid, (LPUNKNOWN*)&lpMsg)) {
IMPORT_LOG1("*** Error opening messages in mailbox: %S\n",
static_cast<const wchar_t*>(pName.get()));
m_mapi.MAPIFreeBuffer(value);
return NS_ERROR_FAILURE;
}
// This is a contact, add it to the address book!
subject.Truncate();
pVal = m_mapi.GetMapiProperty(lpMsg, PR_SUBJECT);
if (pVal) m_mapi.GetStringFromProp(pVal, subject);
nsCOMPtr<nsIAbCard> newCard =
do_CreateInstance("@mozilla.org/addressbook/cardproperty;1", &rv);
if (newCard) {
if (BuildCard(subject.get(), pDirectory, newCard, lpMsg, pFieldMap)) {
nsIAbCard* outCard;
newList->AddCard(newCard, &outCard);
}
}
}
m_mapi.MAPIFreeBuffer(value);
nsIAbDirectory* outList;
rv = pDirectory->AddMailList(newList, &outList);
return rv;
}
void nsOutlookMail::SanitizeValue(nsString& val) {
val.ReplaceSubstring(u"\r\n"_ns, u", "_ns);
val.ReplaceChar(u"\r\n", u',');
}
void nsOutlookMail::SplitString(nsString& val1, nsString& val2) {
// Find the last line if there is more than one!
int32_t idx = val1.RFind(u"\x0D\x0A");
int32_t cnt = 2;
if (idx == -1) {
cnt = 1;
idx = val1.RFindChar(13);
}
if (idx == -1) idx = val1.RFindChar(10);
if (idx != -1) {
val2 = Substring(val1, idx + cnt);
val1.SetLength(idx);
SanitizeValue(val1);
}
}
bool nsOutlookMail::BuildCard(const char16_t* pName, nsIAbDirectory* pDirectory,
nsIAbCard* newCard, LPMAPIPROP pUser,
nsIImportFieldMap* pFieldMap) {
nsString lastName;
nsString firstName;
nsString eMail;
nsString nickName;
nsString middleName;
nsString secondEMail;
ULONG emailTag;
LPSPropValue pProp = m_mapi.GetMapiProperty(pUser, PR_EMAIL_ADDRESS);
if (!pProp) {
emailTag = m_mapi.GetEmailPropertyTag(pUser, OUTLOOK_EMAIL1_MAPI_ID1);
if (emailTag) {
pProp = m_mapi.GetMapiProperty(pUser, emailTag);
}
}
if (pProp) {
m_mapi.GetStringFromProp(pProp, eMail);
SanitizeValue(eMail);
}
// for secondary email
emailTag = m_mapi.GetEmailPropertyTag(pUser, OUTLOOK_EMAIL2_MAPI_ID1);
if (emailTag) {
pProp = m_mapi.GetMapiProperty(pUser, emailTag);
if (pProp) {
m_mapi.GetStringFromProp(pProp, secondEMail);
SanitizeValue(secondEMail);
}
}
pProp = m_mapi.GetMapiProperty(pUser, PR_GIVEN_NAME);
if (pProp) {
m_mapi.GetStringFromProp(pProp, firstName);
SanitizeValue(firstName);
}
pProp = m_mapi.GetMapiProperty(pUser, PR_SURNAME);
if (pProp) {
m_mapi.GetStringFromProp(pProp, lastName);
SanitizeValue(lastName);
}
pProp = m_mapi.GetMapiProperty(pUser, PR_MIDDLE_NAME);
if (pProp) {
m_mapi.GetStringFromProp(pProp, middleName);
SanitizeValue(middleName);
}
pProp = m_mapi.GetMapiProperty(pUser, PR_NICKNAME);
if (pProp) {
m_mapi.GetStringFromProp(pProp, nickName);
SanitizeValue(nickName);
}
if (firstName.IsEmpty() && lastName.IsEmpty()) {
firstName = pName;
}
nsString displayName;
pProp = m_mapi.GetMapiProperty(pUser, PR_DISPLAY_NAME);
if (pProp) {
m_mapi.GetStringFromProp(pProp, displayName);
SanitizeValue(displayName);
}
if (displayName.IsEmpty()) {
if (firstName.IsEmpty())
displayName = pName;
else {
displayName = firstName;
if (!middleName.IsEmpty()) {
displayName.Append(char16_t(' '));
displayName.Append(middleName);
}
if (!lastName.IsEmpty()) {
displayName.Append(char16_t(' '));
displayName.Append(lastName);
}
}
}
// We now have the required fields
// write them out followed by any optional fields!
if (!displayName.IsEmpty()) {
newCard->SetDisplayName(displayName);
}
if (!firstName.IsEmpty()) {
newCard->SetFirstName(firstName);
}
if (!lastName.IsEmpty()) {
newCard->SetLastName(lastName);
}
if (!nickName.IsEmpty()) {
newCard->SetPropertyAsAString(kNicknameProperty, nickName);
}
if (!eMail.IsEmpty()) {
newCard->SetPrimaryEmail(eMail);
}
if (!secondEMail.IsEmpty()) {
newCard->SetPropertyAsAString(k2ndEmailProperty, secondEMail);
}
// Do all of the extra fields!
nsString value;
nsString line2;
if (pFieldMap) {
int max = sizeof(gMapiFields) / sizeof(MAPIFields);
for (int i = 0; i < max; i++) {
pProp = m_mapi.GetMapiProperty(pUser, gMapiFields[i].mapiTag);
if (pProp) {
m_mapi.GetStringFromProp(pProp, value);
if (!value.IsEmpty()) {
if (gMapiFields[i].multiLine == kNoMultiLine) {
SanitizeValue(value);
pFieldMap->SetFieldValue(pDirectory, newCard,
gMapiFields[i].mozField, value);
} else if (gMapiFields[i].multiLine == kIsMultiLine) {
pFieldMap->SetFieldValue(pDirectory, newCard,
gMapiFields[i].mozField, value);
} else {
line2.Truncate();
SplitString(value, line2);
if (!value.IsEmpty())
pFieldMap->SetFieldValue(pDirectory, newCard,
gMapiFields[i].mozField, value);
if (!line2.IsEmpty())
pFieldMap->SetFieldValue(pDirectory, newCard,
gMapiFields[i].multiLine, line2);
}
}
}
}
}
return true;
}