/// <summary>
        /// Update the navigation property assignedToTaskBoardFormat in groups
        /// <param name="body"></param>
        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
        /// </summary>
        public RequestInformation CreatePatchRequestInformation(PlannerAssignedToTaskBoardTaskFormat body, Action <AssignedToTaskBoardFormatRequestBuilderPatchRequestConfiguration> requestConfiguration = default)
        {
            _ = body ?? throw new ArgumentNullException(nameof(body));
            var requestInfo = new RequestInformation {
                HttpMethod     = Method.PATCH,
                UrlTemplate    = UrlTemplate,
                PathParameters = PathParameters,
            };

            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
            if (requestConfiguration != null)
            {
                var requestConfig = new AssignedToTaskBoardFormatRequestBuilderPatchRequestConfiguration();
                requestConfiguration.Invoke(requestConfig);
                requestInfo.AddRequestOptions(requestConfig.Options);
                requestInfo.AddHeaders(requestConfig.Headers);
            }
            return(requestInfo);
        }
        public async Async.Task PlannerTaskAssignedToTaskBoardFormatUpdate()
        {
            var group = await CreateGroup();

            this.testGroup = group;
            var plannerPlan = await CreatePlan(group);

            PlannerTask taskToCreate = new PlannerTask();

            taskToCreate.PlanId      = plannerPlan.Id;
            taskToCreate.Title       = "Top";
            taskToCreate.Assignments = new PlannerAssignments();
            taskToCreate.Assignments.AddAssignee("me");

            PlannerTask topTask = await graphClient.Planner.Tasks.Request().AddAsync(taskToCreate);

            taskToCreate             = new PlannerTask();
            taskToCreate.PlanId      = plannerPlan.Id;
            taskToCreate.Title       = "Bottom";
            taskToCreate.Assignments = new PlannerAssignments();
            taskToCreate.Assignments.AddAssignee("me");

            PlannerTask bottomTask = await graphClient.Planner.Tasks.Request().AddAsync(taskToCreate);

            taskToCreate             = new PlannerTask();
            taskToCreate.PlanId      = plannerPlan.Id;
            taskToCreate.Title       = "Middle";
            taskToCreate.Assignments = new PlannerAssignments();
            taskToCreate.Assignments.AddAssignee("me");

            PlannerTask middleTask = await graphClient.Planner.Tasks.Request().AddAsync(taskToCreate);

            // give it two second to ensure asynchronous processing is completed.
            await Async.Task.Delay(10000);

            var myUserId = plannerPlan.CreatedBy.User.Id;

            // get assigned to task board formats of the tasks in plan.
            var taskIdsWithTaskBoardFormats = await graphClient.Planner.Plans[plannerPlan.Id].Tasks.Request().Select("id").Expand("assignedToTaskBoardFormat").GetAsync();
            IDictionary <string, PlannerAssignedToTaskBoardTaskFormat> formatsByTasks = taskIdsWithTaskBoardFormats.ToDictionary(item => item.Id, item => item.AssignedToTaskBoardFormat);

            var bottomTaskFormatUpdate = new PlannerAssignedToTaskBoardTaskFormat();

            bottomTaskFormatUpdate.OrderHintsByAssignee           = new PlannerOrderHintsByAssignee();
            bottomTaskFormatUpdate.OrderHintsByAssignee[myUserId] = $"{formatsByTasks[topTask.Id].GetOrderHintForAssignee(myUserId)} !"; // after top task.

            var middleTaskFormatUpdate = new PlannerAssignedToTaskBoardTaskFormat();

            middleTaskFormatUpdate.OrderHintsByAssignee           = new PlannerOrderHintsByAssignee();
            middleTaskFormatUpdate.OrderHintsByAssignee[myUserId] = $"{formatsByTasks[topTask.Id].GetOrderHintForAssignee(myUserId)} {bottomTaskFormatUpdate.GetOrderHintForAssignee(myUserId)}!"; // after top task, before bottom task's client side new value.

            string etag = formatsByTasks[bottomTask.Id].GetEtag();

            formatsByTasks[bottomTask.Id] = await graphClient
                                            .Planner
                                            .Tasks[bottomTask.Id]
                                            .AssignedToTaskBoardFormat
                                            .Request()
                                            .Header("If-Match", etag)
                                            .Header("Prefer", "return=representation")
                                            .UpdateAsync(bottomTaskFormatUpdate);

            etag = formatsByTasks[middleTask.Id].GetEtag();
            formatsByTasks[middleTask.Id] = await graphClient
                                            .Planner
                                            .Tasks[middleTask.Id]
                                            .AssignedToTaskBoardFormat
                                            .Request()
                                            .Header("If-Match", etag)
                                            .Header("Prefer", "return=representation")
                                            .UpdateAsync(middleTaskFormatUpdate);

            // verify final order
            var orderedTaskFormats = formatsByTasks.OrderBy(kvp => kvp.Value.GetOrderHintForAssignee(myUserId), StringComparer.Ordinal).ToList();

            Assert.AreEqual(topTask.Id, orderedTaskFormats[0].Key);
            Assert.AreEqual(middleTask.Id, orderedTaskFormats[1].Key);
            Assert.AreEqual(bottomTask.Id, orderedTaskFormats[2].Key);
        }