MsGraph Todo $filter Bug: AND/OR Logic Issue & Workarounds

Aug 8, 2025 by Viktoria Ivanova 59 views

MsGraph Todo $filter Issue: Incorrect Logic with AND/OR Conditions

Hey guys! Today, we're diving deep into a peculiar issue encountered while using Microsoft Graph (MsGraph) to filter ToDo tasks. Specifically, we're talking about a bug where the $filter parameter doesn't seem to work correctly when you combine AND and OR logical conditions. This can be a real headache when you're trying to retrieve a specific set of tasks based on multiple criteria. Let's break down the problem, explore how to reproduce it, and discuss potential workarounds.

The Bug: Combined AND/OR Logic in MsGraph Todo $filter

The core issue revolves around filtering ToDo tasks in MsGraph using complex filter expressions. Imagine you need to fetch tasks that meet two primary conditions:

The task title must contain specific text. This is a common requirement for narrowing down tasks based on keywords or project names.
The task must have either a start date or a due date set. This helps in identifying tasks that are actively scheduled or have deadlines.

To achieve this, you might construct a filter string like this:

"contains(title, '[SPECIFIC_TEXT]') and (startDateTime/dateTime ne null or dueDateTime/dateTime ne null)"

This filter aims to retrieve tasks where the title includes a certain text and either the start date or the due date is not empty. However, the problem is that MsGraph doesn't process this filter correctly. Instead of applying both conditions, it seems to ignore the contains(title, '[SPECIFIC_TEXT]') part and filters only by the date conditions (startDateTime/dateTime ne null or dueDateTime/dateTime ne null). This means you get a lot more tasks than you actually need, which defeats the purpose of filtering in the first place.

Why This Matters

This bug can significantly impact applications that rely on precise task filtering. If you're building a task management tool or an integration that needs to fetch specific tasks based on multiple criteria, this issue can lead to incorrect data retrieval and, consequently, flawed application behavior. Imagine a scenario where you're trying to display tasks that are both relevant to a specific project (title contains project name) and have upcoming deadlines (due date set). If the filter doesn't work as expected, you might end up showing irrelevant tasks or missing important deadlines.

Reproduction Steps: How to Trigger the Bug

Reproducing this bug is pretty straightforward. You'll need to use the MsGraph API to query ToDo tasks with the problematic filter string. Here’s a step-by-step guide:

Construct the Filter String: Start by creating the filter string that combines the contains function with the AND and OR operators. The string should look something like this:
```
"contains(title, '[SPECIFIC_TEXT]') and (startDateTime/dateTime ne null or dueDateTime/dateTime ne null)"
```
Replace [SPECIFIC_TEXT] with the text you want to search for in the task titles.
Use the MsGraph API: Use the MsGraph API (via the SDK or direct HTTP requests) to query ToDo tasks from a specific list. The endpoint you’ll be using is:
```
/me/todo/lists/{listId}/tasks
```
Make sure to replace {listId} with the actual ID of your ToDo list.
Apply the Filter: Pass the filter string as a query parameter named $filter. This tells MsGraph to filter the tasks based on your criteria.
```
graphClient.Me.Todo.Lists[myListId].Tasks.GetAsync(rc => rc.QueryParameters.Filter = filter);
```
Here, filter is the filter string we constructed in step 1.
Analyze the Results: Examine the tasks returned by the API. You’ll notice that the results include tasks that don't contain the [SPECIFIC_TEXT] in their titles, indicating that the contains condition was ignored.

Isolating the Issue: Testing Individual Filters

Interestingly, the individual components of the filter work correctly when used in isolation. This makes the bug even more perplexing. Let’s see what happens when we use the filters separately:

Filtering by Title Only

If you use the filter string "contains(title, '[SPECIFIC_TEXT]')", MsGraph correctly returns tasks that contain the specified text in their titles. This shows that the contains function itself is working as expected.

Filtering by Start/Due Dates Only

Similarly, if you use the filter string "startDateTime/dateTime ne null or dueDateTime/dateTime ne null", MsGraph accurately returns tasks that have either a start date or a due date set. This confirms that the date-related conditions and the OR operator are also functioning correctly.

The Problem Emerges with Combination

The issue only arises when you combine these filters using the AND operator. This suggests that there's a problem in how MsGraph handles the combination of AND and OR conditions within the $filter parameter for ToDo tasks.

Possible Workarounds: Getting the Correct Results

While we wait for a fix from Microsoft, there are a few workarounds you can use to achieve the desired filtering:

1. Filter in Code

The most reliable workaround is to fetch all tasks that match the broader criteria (e.g., startDateTime/dateTime ne null or dueDateTime/dateTime ne null) and then filter the results in your application code. This involves retrieving a larger set of tasks and then iterating through them to apply the contains(title, '[SPECIFIC_TEXT]') condition. While this approach might be less efficient than server-side filtering, it ensures that you get the correct results.

var tasks = await graphClient.Me.Todo.Lists[myListId].Tasks
    .GetAsync(rc => rc.QueryParameters.Filter = "startDateTime/dateTime ne null or dueDateTime/dateTime ne null");

var filteredTasks = tasks.Value
    .Where(task => task.Title.Contains("[SPECIFIC_TEXT]"))
    .ToList();

2. Multiple Requests

Another workaround is to make multiple requests to MsGraph, each with a simpler filter. For example, you could first fetch tasks that contain the specific text in their titles and then fetch tasks that have either a start date or a due date. You would then need to intersect the results in your code to find the tasks that meet both conditions. This approach can be more complex to implement and might involve more API calls, but it can be useful in certain scenarios.

var tasksWithText = await graphClient.Me.Todo.Lists[myListId].Tasks
    .GetAsync(rc => rc.QueryParameters.Filter = "contains(title, '[SPECIFIC_TEXT]')");

var tasksWithDates = await graphClient.Me.Todo.Lists[myListId].Tasks
    .GetAsync(rc => rc.QueryParameters.Filter = "startDateTime/dateTime ne null or dueDateTime/dateTime ne null");

var filteredTasks = tasksWithText.Value
    .Intersect(tasksWithDates.Value, new TaskComparer())
    .ToList();

// Assuming TaskComparer implements IEqualityComparer<TodoTask>
public class TaskComparer : IEqualityComparer<TodoTask>
{
    public bool Equals(TodoTask x, TodoTask y)
    {
        return x.Id == y.Id;
    }

    public int GetHashCode(TodoTask obj)
    {
        return obj.Id.GetHashCode();
    }
}

Diving Deeper: Why Is This Happening?

While we don't have a definitive answer from Microsoft, we can speculate on why this bug might be occurring. It's possible that the MsGraph ToDo service has an issue with parsing or processing complex filter expressions that involve both AND and OR operators. The service might be incorrectly prioritizing the OR condition over the AND condition, leading to the observed behavior. Another possibility is that there's a bug in how the contains function interacts with the logical operators in the filter expression.

MsGraph Documentation and Filtering

The official MsGraph documentation provides detailed information on how to use the $filter parameter. It outlines the supported operators and functions, including contains, and, or, and date comparisons. According to the documentation, the filter expression we used should be valid. This further suggests that the issue is not with the filter syntax itself but with how the MsGraph ToDo service processes it.

Conclusion: The Path Forward

The bug in MsGraph's ToDo $filter parameter when using combined AND and OR logic is a significant issue that can impact applications relying on precise task filtering. While we've explored workarounds like filtering in code or using multiple requests, the ideal solution is for Microsoft to address the bug in the MsGraph service itself. By understanding the problem, reproducing it, and implementing temporary solutions, we can continue building robust applications while waiting for a permanent fix. Keep an eye on Microsoft Graph updates and release notes for any news on this issue. And remember, you're not alone in this – many developers face similar challenges when working with complex APIs. Stay curious, keep exploring, and happy coding!