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, 421 insertions, 0 deletions

diff --git a/comm/mailnews/addrbook/src/nsAbDirectoryQuery.cpp b/comm/mailnews/addrbook/src/nsAbDirectoryQuery.cpp
new file mode 100644
index 0000000000..f0f5d18b0c
--- /dev/null
+++ b/comm/mailnews/addrbook/src/nsAbDirectoryQuery.cpp
@@ -0,0 +1,421 @@
+/* -*- 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 "nsIAbCard.h"
+#include "nsAbDirectoryQuery.h"
+#include "nsAbDirectoryQueryProxy.h"
+#include "nsAbBooleanExpression.h"
+#include "nsComponentManagerUtils.h"
+#include "nsString.h"
+#include "nsUnicharUtils.h"
+#include "nsIAbDirSearchListener.h"
+#include "nsISimpleEnumerator.h"
+#include "nsMsgUtils.h"
+#include "nsQueryObject.h"
+
+NS_IMPL_ISUPPORTS(nsAbDirectoryQuerySimpleBooleanExpression,
+                  nsIAbBooleanExpression)
+
+nsAbDirectoryQuerySimpleBooleanExpression::
+    nsAbDirectoryQuerySimpleBooleanExpression()
+    : mOperation(nsIAbBooleanOperationTypes::AND) {}
+
+nsAbDirectoryQuerySimpleBooleanExpression::
+    ~nsAbDirectoryQuerySimpleBooleanExpression() {}
+
+/* attribute nsAbBooleanOperationType operation; */
+NS_IMETHODIMP nsAbDirectoryQuerySimpleBooleanExpression::GetOperation(
+    nsAbBooleanOperationType* aOperation) {
+  if (!aOperation) return NS_ERROR_NULL_POINTER;
+
+  *aOperation = mOperation;
+
+  return NS_OK;
+}
+NS_IMETHODIMP nsAbDirectoryQuerySimpleBooleanExpression::SetOperation(
+    nsAbBooleanOperationType aOperation) {
+  if (aOperation != nsIAbBooleanOperationTypes::AND &&
+      aOperation != nsIAbBooleanOperationTypes::OR)
+    return NS_ERROR_FAILURE;
+
+  mOperation = aOperation;
+
+  return NS_OK;
+}
+
+/* attribute Array<nsISupports> expressions; */
+NS_IMETHODIMP nsAbDirectoryQuerySimpleBooleanExpression::GetExpressions(
+    nsTArray<RefPtr<nsISupports>>& aExpressions) {
+  aExpressions = mExpressions.Clone();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbDirectoryQuerySimpleBooleanExpression::SetExpressions(
+    const nsTArray<RefPtr<nsISupports>>& aExpressions) {
+  // Ensure all the items are of the right type.
+  nsresult rv;
+  nsCOMPtr<nsIAbBooleanConditionString> queryExpression;
+  for (auto expression : aExpressions) {
+    queryExpression = do_QueryInterface(expression, &rv);
+    if (NS_FAILED(rv)) return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  // Values ok, so we can just save and return.
+  mExpressions = aExpressions.Clone();
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsAbDirectoryQueryArguments, nsIAbDirectoryQueryArguments)
+
+nsAbDirectoryQueryArguments::nsAbDirectoryQueryArguments()
+    : mQuerySubDirectories(true) {}
+
+nsAbDirectoryQueryArguments::~nsAbDirectoryQueryArguments() {}
+
+/* attribute nsISupports matchItems; */
+NS_IMETHODIMP nsAbDirectoryQueryArguments::GetExpression(
+    nsISupports** aExpression) {
+  if (!aExpression) return NS_ERROR_NULL_POINTER;
+
+  NS_IF_ADDREF(*aExpression = mExpression);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbDirectoryQueryArguments::SetExpression(
+    nsISupports* aExpression) {
+  mExpression = aExpression;
+  return NS_OK;
+}
+
+/* attribute boolean querySubDirectories; */
+NS_IMETHODIMP nsAbDirectoryQueryArguments::GetQuerySubDirectories(
+    bool* aQuerySubDirectories) {
+  NS_ENSURE_ARG_POINTER(aQuerySubDirectories);
+  *aQuerySubDirectories = mQuerySubDirectories;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbDirectoryQueryArguments::SetQuerySubDirectories(
+    bool aQuerySubDirectories) {
+  mQuerySubDirectories = aQuerySubDirectories;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbDirectoryQueryArguments::GetTypeSpecificArg(
+    nsISupports** aArg) {
+  NS_ENSURE_ARG_POINTER(aArg);
+
+  NS_IF_ADDREF(*aArg = mTypeSpecificArg);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbDirectoryQueryArguments::SetTypeSpecificArg(
+    nsISupports* aArg) {
+  mTypeSpecificArg = aArg;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbDirectoryQueryArguments::GetFilter(nsACString& aFilter) {
+  aFilter.Assign(mFilter);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAbDirectoryQueryArguments::SetFilter(
+    const nsACString& aFilter) {
+  mFilter.Assign(aFilter);
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsAbDirectoryQueryPropertyValue,
+                  nsIAbDirectoryQueryPropertyValue)
+
+nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue() {}
+
+nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue(
+    const char* aName, const char16_t* aValue) {
+  mName = aName;
+  mValue = aValue;
+}
+
+nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue(
+    const char* aName, nsISupports* aValueISupports) {
+  mName = aName;
+  mValueISupports = aValueISupports;
+}
+
+nsAbDirectoryQueryPropertyValue::~nsAbDirectoryQueryPropertyValue() {}
+
+/* read only attribute string name; */
+NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetName(char** aName) {
+  *aName = mName.IsEmpty() ? 0 : ToNewCString(mName);
+
+  return NS_OK;
+}
+
+/* read only attribute wstring value; */
+NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetValue(char16_t** aValue) {
+  *aValue = ToNewUnicode(mValue);
+  if (!(*aValue))
+    return NS_ERROR_OUT_OF_MEMORY;
+  else
+    return NS_OK;
+}
+
+/* readonly attribute nsISupports valueISupports; */
+NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetValueISupports(
+    nsISupports** aValueISupports) {
+  if (!mValueISupports) return NS_ERROR_NULL_POINTER;
+
+  NS_IF_ADDREF(*aValueISupports = mValueISupports);
+  return NS_OK;
+}
+
+/* Implementation file */
+NS_IMPL_ISUPPORTS(nsAbDirectoryQuery, nsIAbDirectoryQuery)
+
+nsAbDirectoryQuery::nsAbDirectoryQuery() {}
+
+nsAbDirectoryQuery::~nsAbDirectoryQuery() {}
+
+NS_IMETHODIMP nsAbDirectoryQuery::DoQuery(
+    nsIAbDirectory* aDirectory, nsIAbDirectoryQueryArguments* arguments,
+    nsIAbDirSearchListener* listener, int32_t resultLimit, int32_t timeOut,
+    int32_t* _retval) {
+  NS_ENSURE_ARG_POINTER(aDirectory);
+
+  nsCOMPtr<nsISupports> supportsExpression;
+  nsresult rv = arguments->GetExpression(getter_AddRefs(supportsExpression));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAbBooleanExpression> expression(
+      do_QueryInterface(supportsExpression, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool doSubDirectories;
+  rv = arguments->GetQuerySubDirectories(&doSubDirectories);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = query(aDirectory, expression, listener, doSubDirectories, &resultLimit);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = listener->OnSearchFinished(rv, true, nullptr, ""_ns);
+
+  *_retval = 0;
+  return rv;
+}
+
+/* void stopQuery (in long contextID); */
+NS_IMETHODIMP nsAbDirectoryQuery::StopQuery(int32_t contextID) { return NS_OK; }
+
+nsresult nsAbDirectoryQuery::query(nsIAbDirectory* directory,
+                                   nsIAbBooleanExpression* expression,
+                                   nsIAbDirSearchListener* listener,
+                                   bool doSubDirectories,
+                                   int32_t* resultLimit) {
+  if (*resultLimit == 0) return NS_OK;
+
+  nsresult rv = queryCards(directory, expression, listener, resultLimit);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (*resultLimit != 0 && doSubDirectories) {
+    rv = queryChildren(directory, expression, listener, doSubDirectories,
+                       resultLimit);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return rv;
+}
+
+nsresult nsAbDirectoryQuery::queryChildren(nsIAbDirectory* directory,
+                                           nsIAbBooleanExpression* expression,
+                                           nsIAbDirSearchListener* listener,
+                                           bool doSubDirectories,
+                                           int32_t* resultLimit) {
+  nsTArray<RefPtr<nsIAbDirectory>> subDirectories;
+  nsresult rv = directory->GetChildNodes(subDirectories);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (nsIAbDirectory* subDirectory : subDirectories) {
+    rv = query(subDirectory, expression, listener, doSubDirectories,
+               resultLimit);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+nsresult nsAbDirectoryQuery::queryCards(nsIAbDirectory* directory,
+                                        nsIAbBooleanExpression* expression,
+                                        nsIAbDirSearchListener* listener,
+                                        int32_t* resultLimit) {
+  nsTArray<RefPtr<nsIAbCard>> cards;
+  nsresult rv = directory->GetChildCards(cards);
+  if (rv == NS_ERROR_NOT_IMPLEMENTED) {
+    return NS_OK;
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (nsIAbCard* card : cards) {
+    rv = matchCard(card, expression, listener, resultLimit);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (*resultLimit == 0) return NS_OK;
+  }
+
+  return NS_OK;
+}
+
+nsresult nsAbDirectoryQuery::matchCard(nsIAbCard* card,
+                                       nsIAbBooleanExpression* expression,
+                                       nsIAbDirSearchListener* listener,
+                                       int32_t* resultLimit) {
+  bool matchFound = false;
+  nsresult rv = matchCardExpression(card, expression, &matchFound);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (matchFound) {
+    (*resultLimit)--;
+    rv = listener->OnSearchFoundCard(card);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return rv;
+}
+
+nsresult nsAbDirectoryQuery::matchCardExpression(
+    nsIAbCard* card, nsIAbBooleanExpression* expression, bool* result) {
+  nsAbBooleanOperationType operation;
+  nsresult rv = expression->GetOperation(&operation);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<RefPtr<nsISupports>> childExpressions;
+  rv = expression->GetExpressions(childExpressions);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t count = childExpressions.Length();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (operation == nsIAbBooleanOperationTypes::NOT && count > 1)
+    return NS_ERROR_FAILURE;
+
+  bool value = *result = false;
+  nsCOMPtr<nsIAbBooleanConditionString> childCondition;
+  nsCOMPtr<nsIAbBooleanExpression> childExpression;
+
+  for (uint32_t i = 0; i < count; i++) {
+    childCondition = do_QueryObject(childExpressions[i], &rv);
+    if (NS_SUCCEEDED(rv)) {
+      rv = matchCardCondition(card, childCondition, &value);
+      NS_ENSURE_SUCCESS(rv, rv);
+    } else {
+      childExpression = do_QueryObject(childExpressions[i], &rv);
+      if (NS_SUCCEEDED(rv)) {
+        rv = matchCardExpression(card, childExpression, &value);
+        NS_ENSURE_SUCCESS(rv, rv);
+      } else
+        return NS_ERROR_FAILURE;
+    }
+    if (operation == nsIAbBooleanOperationTypes::OR && value)
+      break;
+    else if (operation == nsIAbBooleanOperationTypes::AND && !value)
+      break;
+    else if (operation == nsIAbBooleanOperationTypes::NOT)
+      value = !value;
+  }
+  *result = value;
+
+  return NS_OK;
+}
+
+nsresult nsAbDirectoryQuery::matchCardCondition(
+    nsIAbCard* card, nsIAbBooleanConditionString* condition, bool* matchFound) {
+  nsAbBooleanConditionType conditionType;
+  nsresult rv = condition->GetCondition(&conditionType);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString name;
+  rv = condition->GetName(getter_Copies(name));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (name.Equals("card:nsIAbCard")) {
+    *matchFound = (conditionType == nsIAbBooleanConditionTypes::Exists);
+    return NS_OK;
+  }
+
+  nsString matchValue;
+  rv = condition->GetValue(getter_Copies(matchValue));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (name.EqualsLiteral("IsMailList")) {
+    bool isMailList;
+    rv = card->GetIsMailList(&isMailList);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Only equals is supported.
+    if (conditionType != nsIAbBooleanConditionTypes::Is)
+      return NS_ERROR_FAILURE;
+
+    *matchFound = isMailList ? matchValue.EqualsLiteral("TRUE")
+                             : matchValue.EqualsLiteral("FALSE");
+    return NS_OK;
+  }
+
+  nsString value;
+  (void)card->GetPropertyAsAString(name.get(), value);
+
+  if (value.IsEmpty()) {
+    *matchFound = (conditionType == nsIAbBooleanConditionTypes::DoesNotExist)
+                      ? true
+                      : false;
+    return NS_OK;
+  }
+
+  /* TODO
+   * What about allowing choice between case insensitive
+   * and case sensitive comparisons?
+   *
+   */
+  switch (conditionType) {
+    case nsIAbBooleanConditionTypes::Exists:
+      *matchFound = true;
+      break;
+    case nsIAbBooleanConditionTypes::Contains:
+      *matchFound = CaseInsensitiveFindInReadable(matchValue, value);
+      break;
+    case nsIAbBooleanConditionTypes::DoesNotContain:
+      *matchFound = !CaseInsensitiveFindInReadable(matchValue, value);
+      break;
+    case nsIAbBooleanConditionTypes::Is:
+      *matchFound = value.Equals(matchValue, nsCaseInsensitiveStringComparator);
+      break;
+    case nsIAbBooleanConditionTypes::IsNot:
+      *matchFound =
+          !value.Equals(matchValue, nsCaseInsensitiveStringComparator);
+      break;
+    case nsIAbBooleanConditionTypes::BeginsWith:
+      *matchFound = StringBeginsWith(value, matchValue,
+                                     nsCaseInsensitiveStringComparator);
+      break;
+    case nsIAbBooleanConditionTypes::LessThan:
+      *matchFound =
+          Compare(value, matchValue, nsCaseInsensitiveStringComparator) < 0;
+      break;
+    case nsIAbBooleanConditionTypes::GreaterThan:
+      *matchFound =
+          Compare(value, matchValue, nsCaseInsensitiveStringComparator) > 0;
+      break;
+    case nsIAbBooleanConditionTypes::EndsWith:
+      *matchFound =
+          StringEndsWith(value, matchValue, nsCaseInsensitiveStringComparator);
+      break;
+    case nsIAbBooleanConditionTypes::SoundsLike:
+    case nsIAbBooleanConditionTypes::RegExp:
+      *matchFound = false;
+      break;
+    default:
+      *matchFound = false;
+  }
+
+  return rv;
+}