int MAPIRfc2445::GetNumHiddenAttachments()
{
int retval = 0;
HRESULT hr = S_OK;
LPCWSTR errMsg;
Zimbra::Util::ScopedInterface<IStream> pSrcStream;
Zimbra::Util::ScopedRowSet pAttachRows;
Zimbra::Util::ScopedInterface<IMAPITable> pAttachTable;
SizedSPropTagArray(1, attachProps) = {
1, { PR_ATTACHMENT_HIDDEN }
};
hr = m_pMessage->GetAttachmentTable(MAPI_UNICODE, pAttachTable.getptr());
if (SUCCEEDED(hr))
{
if (FAILED(hr = pAttachTable->SetColumns((LPSPropTagArray) &attachProps, 0)))
{
errMsg = FormatExceptionInfo(hr, L"Error setting attachment table columns", __FILE__, __LINE__);
dlogw(errMsg);
return 0;
}
ULONG ulRowCount = 0;
if (FAILED(hr = pAttachTable->GetRowCount(0, &ulRowCount)))
{
errMsg = FormatExceptionInfo(hr, L"Error getting attachment table row count", __FILE__, __LINE__);
dlogw(errMsg);
return 0;
}
if (FAILED(hr = pAttachTable->QueryRows(ulRowCount, 0, pAttachRows.getptr())))
{
errMsg = FormatExceptionInfo(hr, L"Error querying attachment table rows", __FILE__, __LINE__);
dlogw(errMsg);
return 0;
}
if (SUCCEEDED(hr))
{
hr = MAPI_E_NOT_FOUND;
for (unsigned int i = 0; i < pAttachRows->cRows; i++)
{
// if property couldn't be found or returns error, skip it
if ((pAttachRows->aRow[i].lpProps[0].ulPropTag != PT_ERROR) &&
(pAttachRows->aRow[i].lpProps[0].Value.err != MAPI_E_NOT_FOUND))
{
if (pAttachRows->aRow[i].lpProps[0].Value.b)
{
retval++;
}
}
}
}
}
else
{
errMsg = FormatExceptionInfo(hr, L"Error getting attachment tables", __FILE__, __LINE__);
dlogw(errMsg);
return 0;
}
return retval;
}
MAPIAppointment::MAPIAppointment(Zimbra::MAPI::MAPISession &session, Zimbra::MAPI::MAPIStore &store, Zimbra::MAPI::MAPIMessage &mMessage, int exceptionType)
: MAPIRfc2445 (session, mMessage)
{
m_mapiStore = &store;
m_iExceptionType = exceptionType;
SetExceptionType(exceptionType);
pInvTz = NULL;
_pTzString = NULL;
m_pAddrBook = NULL;
//if (MAPIAppointment::m_bNamedPropsInitialized == false)
//{
pr_clean_global_objid = 0;
pr_appt_start = 0;
pr_appt_end = 0;
pr_location = 0;
pr_busystatus = 0;
pr_allday = 0;
pr_isrecurring = 0;
pr_recurstream = 0;
pr_timezoneid = 0;
pr_reminderminutes = 0;
pr_private = 0;
pr_reminderset =0;
pr_responsestatus = 0;
pr_exceptionreplacetime = 0;
InitNamedPropsForAppt();
//}
m_pSubject = L"";
m_pStartDate = L"";
m_pStartDateForRecID = L"";
m_pEndDate = L"";
m_pInstanceUID = L"";
m_pLocation = L"";
m_pBusyStatus = L"";
m_pAllday = L"";
m_pTransparency = L"";
m_pReminderMinutes = L"";
m_pCurrentStatus = L"";
m_pResponseStatus = L"";
m_pOrganizerName = L"";
m_pOrganizerAddr = L"";
m_pPrivate = L"";
m_pReminderSet = L"";
m_pResponseRequested = L"";
HRESULT hr=session.OpenAddressBook(&m_pAddrBook);
if(!SUCCEEDED(hr))
{
m_pAddrBook=NULL;
}
hr = SetMAPIAppointmentValues();
if(FAILED(hr))
{
dlogw("MapiAppt::SetMAPIAppointmentValues failed");
}
}
HRESULT MAPITask::SetMAPITaskValues()
{
SizedSPropTagArray(T_NUMALLTASKPROPS, taskProps) = {
T_NUMALLTASKPROPS, {
PR_MESSAGE_FLAGS, PR_SUBJECT, PR_BODY, PR_HTML, PR_IMPORTANCE, pr_isrecurringt, pr_recurstreamt, pr_status,
pr_percentcomplete, pr_taskstart, pr_taskdue, pr_totalwork,
pr_actualwork, pr_companies, pr_mileage, pr_billinginfo,
pr_taskreminderset, pr_taskflagdueby, pr_private
}
};
HRESULT hr = S_OK;
ULONG cVals = 0;
m_bHasAttachments = false;
m_bIsRecurring = false;
m_bIsTaskReminderSet = false;
if (FAILED(hr = m_pMessage->GetProps((LPSPropTagArray) & taskProps, fMapiUnicode, &cVals,
&m_pPropVals)))
throw MAPITaskException(hr, L"SetMAPITaskValues(): GetProps Failed.",
ERR_MAPI_TASK, __LINE__, __FILE__);
if (m_pPropVals[T_MESSAGE_FLAGS].ulPropTag == taskProps.aulPropTag[T_MESSAGE_FLAGS])
{
m_bHasAttachments = (m_pPropVals[T_MESSAGE_FLAGS].Value.l & MSGFLAG_HASATTACH) != 0;
}
if (m_pPropVals[T_ISRECURT].ulPropTag == taskProps.aulPropTag[T_ISRECURT]) // do this first to set dates correctly
{
m_bIsRecurring = (m_pPropVals[T_ISRECURT].Value.b == 1);
}
if (m_pPropVals[T_TASKREMINDERSET].ulPropTag == taskProps.aulPropTag[T_TASKREMINDERSET]) // do this first to set dates correctly
{
m_bIsTaskReminderSet = (m_pPropVals[T_TASKREMINDERSET].Value.b == 1);
}
if (m_pPropVals[T_SUBJECT].ulPropTag == taskProps.aulPropTag[T_SUBJECT])
{
SetSubject(m_pPropVals[T_SUBJECT].Value.lpszW);
}
if (m_pPropVals[T_IMPORTANCE].ulPropTag == taskProps.aulPropTag[T_IMPORTANCE])
{
SetImportance(m_pPropVals[T_IMPORTANCE].Value.l);
}
if (m_pPropVals[T_STATUS].ulPropTag == taskProps.aulPropTag[T_STATUS])
{
SetTaskStatus(m_pPropVals[T_STATUS].Value.l);
}
if (m_pPropVals[T_PERCENTCOMPLETE].ulPropTag == taskProps.aulPropTag[T_PERCENTCOMPLETE])
{
SetPercentComplete(m_pPropVals[T_PERCENTCOMPLETE].Value.dbl);
}
if (m_pPropVals[T_TASKSTART].ulPropTag == taskProps.aulPropTag[T_TASKSTART])
{
SetTaskStart(m_pPropVals[T_TASKSTART].Value.ft);
}
if (m_pPropVals[T_TASKDUE].ulPropTag == taskProps.aulPropTag[T_TASKDUE])
{
SetTaskDue(m_pPropVals[T_TASKDUE].Value.ft);
}
if (m_pPropVals[T_TOTALWORK].ulPropTag == taskProps.aulPropTag[T_TOTALWORK])
{
SetTotalWork(m_pPropVals[T_TOTALWORK].Value.l);
}
if (m_pPropVals[T_ACTUALWORK].ulPropTag == taskProps.aulPropTag[T_ACTUALWORK])
{
SetActualWork(m_pPropVals[T_ACTUALWORK].Value.l);
}
if (m_pPropVals[T_COMPANIES].ulPropTag == taskProps.aulPropTag[T_COMPANIES])
{
SetCompanies(m_pPropVals[T_COMPANIES].Value.MVszW.lppszW[0]); // get first one for now
}
if (m_pPropVals[T_MILEAGE].ulPropTag == taskProps.aulPropTag[T_MILEAGE])
{
SetMileage(m_pPropVals[T_MILEAGE].Value.lpszW);
}
if (m_pPropVals[T_BILLING].ulPropTag == taskProps.aulPropTag[T_BILLING])
{
SetBillingInfo(m_pPropVals[T_BILLING].Value.lpszW);
}
if (m_pPropVals[T_TASKFLAGDUEBY].ulPropTag == taskProps.aulPropTag[T_TASKFLAGDUEBY])
{
SetTaskFlagDueBy(m_pPropVals[T_TASKFLAGDUEBY].Value.ft);
}
if (m_pPropVals[T_PRIVATE].ulPropTag == taskProps.aulPropTag[T_PRIVATE])
{
SetPrivate(m_pPropVals[T_PRIVATE].Value.b);
}
SetPlainTextFileAndContent();
SetHtmlFileAndContent();
if (m_bHasAttachments)
{
if (FAILED(ExtractAttachments()))
{
dlogw(L"Could not extract attachments");
}
}
if (m_bIsRecurring)
{
if (m_pPropVals[T_RECURSTREAMT].ulPropTag == taskProps.aulPropTag[T_RECURSTREAMT])
{
SetRecurValues();
}
}
return hr;
}
HRESULT MAPIRfc2445::ExtractAttachments()
{
// may need to break this up so we can call for exceptions, cancel exceptions
LPCWSTR errMsg;
Zimbra::Util::ScopedInterface<IStream> pIStream;
UINT mimeLen = 0;
HRESULT hr = ConvertIt( m_pMessage, pIStream.getptr(), mimeLen );
if (FAILED(hr))
{
errMsg = FormatExceptionInfo(hr, L"Mime conversion of message with attachments failed", __FILE__, __LINE__);
dlogw(errMsg);
return hr;
}
mimepp::Message mimeMsg;
Zimbra::Util::ScopedBuffer<CHAR> pszMimeMsg;
// go to the beginning of the stream
LARGE_INTEGER li = { 0 };
hr = pIStream->Seek(li, STREAM_SEEK_SET, NULL);
if (FAILED(hr))
{
errMsg = FormatExceptionInfo(hr, L"Stream seek failed", __FILE__, __LINE__);
dlogw(errMsg);
return hr;
}
// +1 for NULL terminator
Zimbra::Mapi::Memory::AllocateBuffer(mimeLen + 1, (LPVOID *)pszMimeMsg.getptr());
if (!pszMimeMsg.get())
{
errMsg = FormatExceptionInfo(S_OK, L"Mime msg Memory alloc failed", __FILE__, __LINE__);
dlogw(errMsg);
return hr;
}
ULONG ulNumRead = 0;
hr = pIStream->Read((LPVOID)(pszMimeMsg.get()), mimeLen, &ulNumRead);
if (FAILED(hr))
{
errMsg = FormatExceptionInfo(hr, L"Mime msg read failed", __FILE__, __LINE__);
dlogw(errMsg);
return hr;
}
if (ulNumRead != mimeLen)
{
errMsg = FormatExceptionInfo(hr, L"Mime msg read error", __FILE__, __LINE__);
dlogw(errMsg);
return hr;
}
// terminating string
pszMimeMsg.get()[mimeLen] = '\0';
mimeMsg.setString(pszMimeMsg.get());
mimeMsg.parse();
// let's see if this message is a multipart alternative before we continue
mimepp::Headers &theHeaders = mimeMsg.headers();
LPSTR pszContentType;
GetContentType(theHeaders, &pszContentType);
if(strncmp(pszContentType, "multipart/mixed", strlen("multipart/mixed")) != 0)
{
// not what we are looking for
delete[] pszContentType;
return S_OK;
}
const mimepp::Body& theBody = mimeMsg.body();
int numParts = theBody.numBodyParts();
// FBS bug 73682 -- 5/23/12
int numHiddenAttachments = GetNumHiddenAttachments();
int totalAttachments = numParts - 1;
if (totalAttachments == numHiddenAttachments)
{
return S_OK;
}
// let's look for a multipart mixed and grab the attachments
int ctr = numHiddenAttachments;
for(int i = 0; i < numParts; i++)
{
// now look for attachments
const mimepp::BodyPart& thePart = theBody.bodyPartAt(i);
mimepp::DispositionType& disposition = thePart.headers().contentDisposition();
if(disposition.asEnum() == mimepp::DispositionType::ATTACHMENT)
{
const mimepp::String& theFilename = disposition.filename();
LPSTR pszAttachContentType;
LPSTR pszCD;
LPSTR lpszRealName = new char[256];
GetContentType(thePart.headers(), &pszAttachContentType);
// FBS bug 73682 -- Exceptions are at the beginning. Don't make attachments for those
if (ctr > 0)
{
if (0 == strcmpi(pszAttachContentType, "message/rfc822"))
{
ctr--;
continue;
}
}
//
if((LPSTR)theFilename.length()>0)
{
GenerateContentDisposition(&pszCD, (LPSTR)theFilename.c_str());
strcpy(lpszRealName, (LPSTR)theFilename.c_str());
}
else
{
char cfilename[64];
sprintf(cfilename,"attachment-%d",i);
GenerateContentDisposition(&pszCD, cfilename);
strcpy(lpszRealName, cfilename);
}
// now deal with the encoding
LPSTR pContent = NULL;
const mimepp::String &theContent = thePart.body().getString();
mimepp::String outputString;
UINT size = 0;
mimepp::TransferEncodingType& transferEncoding = thePart.headers().contentTransferEncoding();
if(transferEncoding.asEnum() == mimepp::TransferEncodingType::BASE64)
{
// let's decode the buffer
mimepp::Base64Decoder decoder;
outputString = decoder.decode(theContent);
pContent = (LPSTR)outputString.c_str();
size = (UINT)outputString.size();
}
else if(transferEncoding.asEnum() == mimepp::TransferEncodingType::QUOTED_PRINTABLE)
{
mimepp::QuotedPrintableDecoder decoder;
outputString = decoder.decode(theContent);
pContent = (LPSTR)outputString.c_str();
size = (UINT)outputString.size();
}
else
{
pContent = (LPSTR)theContent.c_str();
size = (UINT)theContent.size();
}
// Save stream to temp file in temp dir. We'll delete in ZimbraAPI //
LPCWSTR errMsg;
HRESULT hr = S_OK;
wstring wstrTempAppDirPath;
LPSTR lpszFQFileName = new char[256];
LPSTR lpszDirName = NULL;
LPSTR lpszUniqueName = NULL;
Zimbra::Util::ScopedInterface<IStream> pStream;
if (!Zimbra::MAPI::Util::GetAppTemporaryDirectory(wstrTempAppDirPath))
{
errMsg = FormatExceptionInfo(S_OK, L"GetAppTemporaryDirectory Failed", __FILE__, __LINE__);
dloge("MAPIRfc2445 -- exception");
dloge(errMsg);
return E_FAIL;
}
WtoA((LPWSTR)wstrTempAppDirPath.c_str(), lpszDirName);
WtoA((LPWSTR)Zimbra::MAPI::Util::GetUniqueName().c_str(), lpszUniqueName);
strcpy(lpszFQFileName, lpszDirName);
strcat(lpszFQFileName, "\\");
strcat(lpszFQFileName, lpszUniqueName);
SafeDelete(lpszDirName);
SafeDelete(lpszUniqueName);
// Open stream on file
if (FAILED(hr = OpenStreamOnFile(MAPIAllocateBuffer, MAPIFreeBuffer, STGM_CREATE |
STGM_READWRITE, (LPTSTR)lpszFQFileName, NULL, pStream.getptr())))
{
errMsg = FormatExceptionInfo(hr, L"Error: OpenStreamOnFile Failed.", __FILE__, __LINE__);
dloge("MAPIRfc2445 -- exception");
dloge(errMsg);
return hr;
}
ULONG nBytesToWrite = size;
ULONG nBytesWritten = 0;
LPBYTE pCur = (LPBYTE)pContent;
while (!FAILED(hr) && nBytesToWrite > 0)
{
hr = pStream->Write(pCur, nBytesToWrite, &nBytesWritten);
pCur += nBytesWritten;
nBytesToWrite -= nBytesWritten;
}
if (FAILED(hr = pStream->Commit(0)))
{
errMsg = FormatExceptionInfo(hr, L"Error: Stream Write Failed.", __FILE__, __LINE__);
dloge("MAPIRfc2445 -- exception");
dloge(errMsg);
}
///////////
// delete all this in MAPIAccessWrap
AttachmentInfo* pAttachmentInfo = new AttachmentInfo();
pAttachmentInfo->pszTempFile = lpszFQFileName;
pAttachmentInfo->pszRealName = lpszRealName;
pAttachmentInfo->pszContentDisposition = pszCD;
pAttachmentInfo->pszContentType = pszAttachContentType;
m_vAttachments.push_back(pAttachmentInfo);
}
}
delete[] pszContentType;
return S_OK;
}
HRESULT MAPIAppointment::SetOrganizerAndAttendees()
{
Zimbra::Util::ScopedInterface<IMAPITable> pRecipTable;
HRESULT hr = 0;
hr = m_pMessage->GetRecipientTable(fMapiUnicode, pRecipTable.getptr());
if (FAILED(hr))
{
return hr;
}
typedef enum _AttendeePropTagIdx
{
AT_ADDRTYPE, AT_ENTRYID, AT_DISPLAY_NAME, AT_SMTP_ADDR, AT_RECIPIENT_FLAGS, AT_RECIPIENT_TYPE, AT_RECIPIENT_TRACKSTATUS,AT_EMAIL_ADDRESS, AT_NPROPS
} AttendeePropTagIdx;
SizedSPropTagArray(AT_NPROPS, reciptags) = {
AT_NPROPS, { PR_ADDRTYPE, PR_ENTRYID, PR_DISPLAY_NAME_W, PR_SMTP_ADDRESS_W, PR_RECIPIENT_FLAGS, PR_RECIPIENT_TYPE, PR_RECIPIENT_TRACKSTATUS,PR_EMAIL_ADDRESS }
};
ULONG ulRows = 0;
Zimbra::Util::ScopedRowSet pRecipRows;
hr = pRecipTable->SetColumns((LPSPropTagArray) & reciptags, 0);
if (FAILED(hr))
{
//LOG_ERROR(_T("could not get the recipient table, hr: %x"), hr);
return hr;
}
hr = pRecipTable->GetRowCount(0, &ulRows);
if (FAILED(hr))
{
//LOG_ERROR(_T("could not get the recipient table row count, hr: %x"), hr);
return hr;
}
hr = pRecipTable->QueryRows(ulRows, 0, pRecipRows.getptr());
if (FAILED(hr))
{
//LOG_ERROR(_T("Failed to query table rows. hr: %x"), hr);
return hr;
}
if (pRecipRows != NULL)
{
for (ULONG iRow = 0; iRow < pRecipRows->cRows; iRow++)
{
if (pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_FLAGS].ulPropTag ==
reciptags.aulPropTag[AT_RECIPIENT_FLAGS])
{
if (pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_FLAGS].Value.l == 3)
{
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_DISPLAY_NAME].ulPropTag) != PT_ERROR)
{
m_pOrganizerName = pRecipRows->aRow[iRow].lpProps[AT_DISPLAY_NAME].Value.lpszW;
}
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_SMTP_ADDR].ulPropTag) != PT_ERROR)
{
m_pOrganizerAddr = pRecipRows->aRow[iRow].lpProps[AT_SMTP_ADDR].Value.lpszW;
}
if((lstrcmpiW(m_pOrganizerAddr.c_str(),L"") == 0) ||(m_pOrganizerName ==L""))
{
Attendee* pAttendee = new Attendee();
dlogi("Going to Update organizer from EID...");
if(UpdateAttendeeFromEntryId(*pAttendee,pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value.bin) !=S_OK)
{
dlogi("Going to update organizer from AD");
RECIP_INFO tempRecip;
tempRecip.pAddrType = NULL;
tempRecip.pEmailAddr = NULL;
tempRecip.cbEid = 0;
tempRecip.pEid = NULL;
tempRecip.pAddrType =
pRecipRows->aRow[iRow].lpProps[AT_ADDRTYPE].Value.lpszW;
tempRecip.pEmailAddr =
pRecipRows->aRow[iRow].lpProps[AT_EMAIL_ADDRESS].Value.lpszW;
if (pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].ulPropTag != PT_ERROR)
{
tempRecip.cbEid =
pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value.bin.cb;
tempRecip.pEid =
(LPENTRYID)pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value
.bin.lpb;
}
std::wstring wstrEmailAddress;
try
{
Zimbra::MAPI::Util::GetSMTPFromAD(*m_session, tempRecip,L"" , L"",wstrEmailAddress);
}
catch(...)
{
dlogw("mapiappointment::exception from MAPi::util::GetSMTPFromAD ");
}
pAttendee->addr = wstrEmailAddress;
dlogi("Email address(AD):",wstrEmailAddress);
dlogi("AD update end.");
}
dlogi("EID update end.");
if(m_pOrganizerAddr==L"")
m_pOrganizerAddr = pAttendee->addr;
if(m_pOrganizerName==L"")
m_pOrganizerName = pAttendee->nam;
}
dlogi("OrganizerAddr: ",m_pOrganizerAddr, " OrganizerName: ",m_pOrganizerName);
}
else
{
if (!(RECIP_FLAG_EXCEP_DELETED & pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_FLAGS].Value.l)) // make sure attendee wasn't deleted
{
Attendee* pAttendee = new Attendee(); // delete done in CMapiAccessWrap::GetData after we allocate dict string for ZimbraAPI
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_DISPLAY_NAME].ulPropTag) != PT_ERROR)
pAttendee->nam = pRecipRows->aRow[iRow].lpProps[AT_DISPLAY_NAME].Value.lpszW;
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_SMTP_ADDR].ulPropTag) != PT_ERROR)
pAttendee->addr = pRecipRows->aRow[iRow].lpProps[AT_SMTP_ADDR].Value.lpszW;
wstring attaddress = pAttendee->addr;
if(lstrcmpiW(attaddress.c_str(),L"") == 0)
{
if (((pAttendee->nam==L"") || (pAttendee->addr==L"")) && (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].ulPropTag) != PT_ERROR))
{
dlogi("Going to Update attendee from EID...");
if(UpdateAttendeeFromEntryId(*pAttendee,pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value.bin)!=S_OK)
{
dlogi("Going to update attendee from AD");
RECIP_INFO tempRecip;
tempRecip.pAddrType = NULL;
tempRecip.pEmailAddr = NULL;
tempRecip.cbEid = 0;
tempRecip.pEid = NULL;
tempRecip.pAddrType =
pRecipRows->aRow[iRow].lpProps[AT_ADDRTYPE].Value.lpszW;
tempRecip.pEmailAddr =
pRecipRows->aRow[iRow].lpProps[AT_EMAIL_ADDRESS].Value.lpszW;
if (pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].ulPropTag != PT_ERROR)
{
tempRecip.cbEid =
pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value.bin.cb;
tempRecip.pEid =
(LPENTRYID)pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value
.bin.lpb;
}
std::wstring wstrEmailAddress;
try
{
Zimbra::MAPI::Util::GetSMTPFromAD(*m_session, tempRecip,L"" , L"",wstrEmailAddress);
}
catch(...)
{
dlogw(" Mapiappoinemtn::Exception in MAPI::Util::GetSMTPFromAD");
}
pAttendee->addr = wstrEmailAddress;
dlogi("Email address(AD):",wstrEmailAddress);
dlogi("AD update end.");
}
dlogi("EID update end.");
}
}
dlogi("AttendeeAddr: ",pAttendee->addr," AttendeeName :",pAttendee->nam);
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_TYPE].ulPropTag) != PT_ERROR)
pAttendee->role = ConvertValueToRole(pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_TYPE].Value.l);
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_TRACKSTATUS].ulPropTag) != PT_ERROR)
pAttendee->partstat = ConvertValueToPartStat(pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_TRACKSTATUS].Value.l);
m_vAttendees.push_back(pAttendee);
}
}
}
}
}
return hr;
}
HRESULT MAPIAppointment::SetMAPIAppointmentValues()
{
SizedSPropTagArray(C_NUMALLAPPTPROPS, appointmentProps) = {
C_NUMALLAPPTPROPS, {
PR_MESSAGE_FLAGS, PR_SUBJECT, PR_BODY, PR_HTML, pr_clean_global_objid,
pr_appt_start, pr_appt_end, pr_location, pr_busystatus, pr_allday,
pr_isrecurring, pr_recurstream, pr_timezoneid, pr_responsestatus,
PR_RESPONSE_REQUESTED,pr_exceptionreplacetime,
pr_reminderminutes, pr_private, pr_reminderset
}
};
HRESULT hr = S_OK;
ULONG cVals = 0;
bool bAllday = false;
m_bHasAttachments = false;
m_bIsRecurring = false;
// get the zimbra appt wrapper around the mapi message
Zimbra::Mapi::Appt appt(m_pMessage, m_mapiStore->GetInternalMAPIStore());
// save off the default timezone info for this appointment
try
{
hr = appt.GetTimezone(_olkTz, &_pTzString);
}
catch(...)
{
hr=E_FAIL;
}
if (SUCCEEDED(hr))
{
// get the timezone info for this appt
pInvTz= new Zimbra::Mail::TimeZone(_pTzString);
pInvTz->Initialize(_olkTz, _pTzString);
}
if (FAILED(hr = m_pMessage->GetProps((LPSPropTagArray) & appointmentProps, fMapiUnicode, &cVals,
&m_pPropVals)))
throw MAPIAppointmentException(hr, L"SetMAPIAppointmentValues(): GetProps Failed.",
ERR_MAPI_APPOINTMENT, __LINE__, __FILE__);
if (m_pPropVals[C_MESSAGE_FLAGS].ulPropTag == appointmentProps.aulPropTag[C_MESSAGE_FLAGS])
{
m_bHasAttachments = (m_pPropVals[C_MESSAGE_FLAGS].Value.l & MSGFLAG_HASATTACH) != 0;
}
if (m_pPropVals[C_ISRECUR].ulPropTag == appointmentProps.aulPropTag[C_ISRECUR]) // do this first to set dates correctly
{
m_bIsRecurring = (m_pPropVals[C_ISRECUR].Value.b == 1);
}
if (m_pPropVals[C_ALLDAY].ulPropTag == appointmentProps.aulPropTag[C_ALLDAY])
{
SetAllday(m_pPropVals[C_ALLDAY].Value.b);
bAllday = (m_pPropVals[C_ALLDAY].Value.b == 1);
}
if (m_pPropVals[C_SUBJECT].ulPropTag == appointmentProps.aulPropTag[C_SUBJECT])
{
SetSubject(m_pPropVals[C_SUBJECT].Value.lpszW);
}
if (m_pPropVals[C_UID].ulPropTag == appointmentProps.aulPropTag[C_UID])
{
SetInstanceUID(&m_pPropVals[C_UID].Value.bin);
}
if (m_pPropVals[C_START].ulPropTag == appointmentProps.aulPropTag[C_START])
{
SetStartDate(m_pPropVals[C_START].Value.ft);
}
if (m_pPropVals[C_END].ulPropTag == appointmentProps.aulPropTag[C_END])
{
SetEndDate(m_pPropVals[C_END].Value.ft, bAllday);
}
if (m_pPropVals[C_LOCATION].ulPropTag == appointmentProps.aulPropTag[C_LOCATION])
{
SetLocation(m_pPropVals[C_LOCATION].Value.lpszW);
}
if (m_pPropVals[C_BUSYSTATUS].ulPropTag == appointmentProps.aulPropTag[C_BUSYSTATUS])
{
SetBusyStatus(m_pPropVals[C_BUSYSTATUS].Value.l);
}
if (m_pPropVals[C_RESPONSESTATUS].ulPropTag == appointmentProps.aulPropTag[C_RESPONSESTATUS])
{
SetResponseStatus(m_pPropVals[C_RESPONSESTATUS].Value.l);
}
if (m_pPropVals[C_RESPONSEREQUESTED].ulPropTag == appointmentProps.aulPropTag[C_RESPONSEREQUESTED])
{
SetResponseRequested(m_pPropVals[C_RESPONSEREQUESTED].Value.b);
}
unsigned short usReminderSet=1;
if (m_pPropVals[C_REMINDERSET].ulPropTag == appointmentProps.aulPropTag[C_REMINDERSET])
{
usReminderSet= m_pPropVals[C_REMINDERSET].Value.b;
}
if(usReminderSet)
{
if (m_pPropVals[C_REMINDERMINUTES].ulPropTag == appointmentProps.aulPropTag[C_REMINDERMINUTES])
{
SetReminderMinutes(m_pPropVals[C_REMINDERMINUTES].Value.l);
}
}
if (m_pPropVals[C_PRIVATE].ulPropTag == appointmentProps.aulPropTag[C_PRIVATE])
{
SetPrivate(m_pPropVals[C_PRIVATE].Value.b);
}
SetTransparency(L"O");
SetPlainTextFileAndContent();
SetHtmlFileAndContent();
if (m_bHasAttachments)
{
if (FAILED(ExtractAttachments()))
{
dlogw(L"Could not extract attachments");
}
}
hr = SetOrganizerAndAttendees();
if(FAILED(hr))
{
dlogw(L"SetOrganizerAndAttendees failed");
}
if ((m_bIsRecurring) && (m_iExceptionType != CANCEL_EXCEPTION))
{
if (m_pPropVals[C_RECURSTREAM].ulPropTag == appointmentProps.aulPropTag[C_RECURSTREAM])
{
// special case for timezone id
if (m_pPropVals[C_TIMEZONEID].ulPropTag == appointmentProps.aulPropTag[C_TIMEZONEID])
{
SetTimezoneId(m_pPropVals[C_TIMEZONEID].Value.lpszW);
}
//
int numExceptions = SetRecurValues(); // returns null if no exceptions
if (numExceptions > 0)
{
SetExceptions();
}
}
}
return hr;
}
