nsresult nsMsgFilterList::SaveTextFilters(nsIOutputStream *aStream)
{
uint32_t filterCount = 0;
nsresult err = GetFilterCount(&filterCount);
NS_ENSURE_SUCCESS(err, err);
err = WriteIntAttr(nsIMsgFilterList::attribVersion, kFileVersion, aStream);
NS_ENSURE_SUCCESS(err, err);
err = WriteBoolAttr(nsIMsgFilterList::attribLogging, m_loggingEnabled, aStream);
NS_ENSURE_SUCCESS(err, err);
for (uint32_t i = 0; i < filterCount; i ++)
{
nsCOMPtr<nsIMsgFilter> filter;
if (NS_SUCCEEDED(GetFilterAt(i, getter_AddRefs(filter))) && filter)
{
filter->SetFilterList(this);
// if the filter is temporary, don't write it to disk
bool isTemporary;
err = filter->GetTemporary(&isTemporary);
if (NS_SUCCEEDED(err) && !isTemporary) {
err = filter->SaveToTextFile(aStream);
if (NS_FAILED(err))
break;
}
}
else
break;
}
if (NS_SUCCEEDED(err))
m_arbitraryHeaders.Truncate();
return err;
}
nsresult
nsMsgFilterList::GetFilterNamed(const nsAString &aName, nsIMsgFilter **aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
uint32_t count = 0;
nsresult rv = GetFilterCount(&count);
NS_ENSURE_SUCCESS(rv, rv);
*aResult = nullptr;
for (uint32_t i = 0; i < count; i++) {
nsCOMPtr<nsIMsgFilter> filter;
rv = GetFilterAt(i, getter_AddRefs(filter));
if (NS_FAILED(rv)) continue;
nsString filterName;
filter->GetFilterName(filterName);
if (filterName.Equals(aName))
{
*aResult = filter;
break;
}
}
NS_IF_ADDREF(*aResult);
return NS_OK;
}
nsresult nsMsgFilterList::GetFilterAt(uint32_t filterIndex, nsIMsgFilter **filter)
{
NS_ENSURE_ARG_POINTER(filter);
uint32_t filterCount = 0;
GetFilterCount(&filterCount);
NS_ENSURE_ARG(filterIndex < filterCount);
NS_IF_ADDREF(*filter = m_filters[filterIndex]);
return NS_OK;
}
NS_IMETHODIMP
nsMsgFilterList::ApplyFiltersToHdr(nsMsgFilterTypeType filterType,
nsIMsgDBHdr *msgHdr,
nsIMsgFolder *folder,
nsIMsgDatabase *db,
const char*headers,
uint32_t headersSize,
nsIMsgFilterHitNotify *listener,
nsIMsgWindow *msgWindow)
{
nsCOMPtr<nsIMsgFilter> filter;
uint32_t filterCount = 0;
nsresult rv = GetFilterCount(&filterCount);
NS_ENSURE_SUCCESS(rv, rv);
nsMsgSearchScopeTerm* scope = new nsMsgSearchScopeTerm(nullptr, nsMsgSearchScope::offlineMail, folder);
scope->AddRef();
if (!scope) return NS_ERROR_OUT_OF_MEMORY;
for (uint32_t filterIndex = 0; filterIndex < filterCount; filterIndex++)
{
if (NS_SUCCEEDED(GetFilterAt(filterIndex, getter_AddRefs(filter))))
{
bool isEnabled;
nsMsgFilterTypeType curFilterType;
filter->GetEnabled(&isEnabled);
if (!isEnabled)
continue;
filter->GetFilterType(&curFilterType);
if (curFilterType & filterType)
{
nsresult matchTermStatus = NS_OK;
bool result;
filter->SetScope(scope);
matchTermStatus = filter->MatchHdr(msgHdr, folder, db, headers, headersSize, &result);
filter->SetScope(nullptr);
if (NS_SUCCEEDED(matchTermStatus) && result && listener)
{
bool applyMore = true;
rv = listener->ApplyFilterHit(filter, msgWindow, &applyMore);
if (NS_FAILED(rv) || !applyMore)
break;
}
}
}
}
scope->Release();
return rv;
}
bool CDirectShowFilterFinder::GetFilterInfo(const int iIndex,CLSID *pidClass,LPWSTR pwszFriendlyName,int iBufLen)
{
if (iIndex<0 || iIndex>=GetFilterCount())
return false;
CFilterInfo &Info = m_FilterList[iIndex];
if (pidClass)
*pidClass = Info.m_clsid;
if (pwszFriendlyName) {
if (Info.m_pwszFriendlyName) {
::lstrcpynW(pwszFriendlyName,Info.m_pwszFriendlyName,iBufLen);
} else if (iBufLen>0) {
pwszFriendlyName[0]='\0';
}
}
return true;
}
// Attempt to move the filter at index filterIndex in the specified direction.
// If motion not possible in that direction, we still return success.
// We could return an error if the FE's want to beep or something.
nsresult nsMsgFilterList::MoveFilterAt(uint32_t filterIndex,
nsMsgFilterMotionValue motion)
{
NS_ENSURE_ARG((motion == nsMsgFilterMotion::up) ||
(motion == nsMsgFilterMotion::down));
uint32_t filterCount = 0;
nsresult rv = GetFilterCount(&filterCount);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_ARG(filterIndex < filterCount);
uint32_t newIndex = filterIndex;
if (motion == nsMsgFilterMotion::up)
{
// are we already at the top?
if (filterIndex == 0)
return NS_OK;
newIndex = filterIndex - 1;
}
else if (motion == nsMsgFilterMotion::down)
{
// are we already at the bottom?
if (filterIndex == filterCount - 1)
return NS_OK;
newIndex = filterIndex + 1;
}
nsCOMPtr<nsIMsgFilter> tempFilter1;
rv = GetFilterAt(newIndex, getter_AddRefs(tempFilter1));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgFilter> tempFilter2;
rv = GetFilterAt(filterIndex, getter_AddRefs(tempFilter2));
NS_ENSURE_SUCCESS(rv, rv);
SetFilterAt(newIndex, tempFilter2);
SetFilterAt(filterIndex, tempFilter1);
return NS_OK;
}
// leaves m_arbitraryHeaders filed in with the arbitrary headers.
nsresult nsMsgFilterList::ComputeArbitraryHeaders()
{
NS_ENSURE_TRUE (m_arbitraryHeaders.IsEmpty(), NS_OK);
uint32_t numFilters = 0;
nsresult rv = GetFilterCount(&numFilters);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgFilter> filter;
nsMsgSearchAttribValue attrib;
nsCString arbitraryHeader;
for (uint32_t index = 0; index < numFilters; index++)
{
rv = GetFilterAt(index, getter_AddRefs(filter));
if (!(NS_SUCCEEDED(rv) && filter)) continue;
nsCOMPtr <nsISupportsArray> searchTerms;
uint32_t numSearchTerms=0;
filter->GetSearchTerms(getter_AddRefs(searchTerms));
if (searchTerms)
searchTerms->Count(&numSearchTerms);
for (uint32_t i = 0; i < numSearchTerms; i++)
{
filter->GetTerm(i, &attrib, nullptr, nullptr, nullptr, arbitraryHeader);
if (!arbitraryHeader.IsEmpty())
{
if (m_arbitraryHeaders.IsEmpty())
m_arbitraryHeaders.Assign(arbitraryHeader);
else if (m_arbitraryHeaders.Find(arbitraryHeader, CaseInsensitiveCompare) == -1)
{
m_arbitraryHeaders.Append(" ");
m_arbitraryHeaders.Append(arbitraryHeader);
}
}
}
}
return NS_OK;
}
NS_IMETHODIMP nsMsgFilterList::MatchOrChangeFilterTarget(const nsACString &oldFolderUri, const nsACString &newFolderUri, bool caseInsensitive, bool *found)
{
NS_ENSURE_ARG_POINTER(found);
uint32_t numFilters = 0;
nsresult rv = GetFilterCount(&numFilters);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgFilter> filter;
nsCString folderUri;
*found = false;
for (uint32_t index = 0; index < numFilters; index++)
{
rv = GetFilterAt(index, getter_AddRefs(filter));
NS_ENSURE_SUCCESS(rv, rv);
uint32_t numActions;
rv = filter->GetActionCount(&numActions);
NS_ENSURE_SUCCESS(rv, rv);
for (uint32_t actionIndex = 0; actionIndex < numActions; actionIndex++)
{
nsCOMPtr<nsIMsgRuleAction> filterAction;
rv = filter->GetActionAt(actionIndex, getter_AddRefs(filterAction));
if (NS_FAILED(rv) || !filterAction)
continue;
nsMsgRuleActionType actionType;
if (NS_FAILED(filterAction->GetType(&actionType)))
continue;
if (actionType == nsMsgFilterAction::MoveToFolder ||
actionType == nsMsgFilterAction::CopyToFolder)
{
rv = filterAction->GetTargetFolderUri(folderUri);
if (NS_SUCCEEDED(rv) && !folderUri.IsEmpty())
{
bool matchFound = false;
if (caseInsensitive)
{
if (folderUri.Equals(oldFolderUri, nsCaseInsensitiveCStringComparator())) //local
matchFound = true;
}
else
{
if (folderUri.Equals(oldFolderUri)) //imap
matchFound = true;
}
if (matchFound)
{
*found = true;
//if we just want to match the uri's, newFolderUri will be null
if (!newFolderUri.IsEmpty())
{
rv = filterAction->SetTargetFolderUri(newFolderUri);
NS_ENSURE_SUCCESS(rv, rv);
}
}
}
}
}
}
return rv;
}
