public void CreateAsync_NewTaskNull_ThrowArgumentNullException()
        {
            WrikeTask newTask = null;

            var ex = Assert.ThrowsAsync <ArgumentNullException>(() =>
                                                                TestConstants.WrikeClient.Tasks.CreateAsync("folderId", newTask));

            Assert.AreEqual("newTask", ex.ParamName);
        }
Esempio n. 2
0
        public void CreateAsync_ShouldAddNewTaskWithTitleAndEmptyCustomFieldData()
        {
            var newTask = new WrikeTask("Test Task #2", customFields: new List <WrikeCustomFieldData> {
                new WrikeCustomFieldData(CustomFieldsTests.DefaultCustomFieldId)
            });

            var createdTask = WrikeClientFactory.GetWrikeClient().Tasks.CreateAsync(PersonalFolderId, newTask).Result;

            Assert.IsNotNull(createdTask);
            Assert.AreEqual(newTask.Title, createdTask.Title);
        }
Esempio n. 3
0
        public void DeleteAsync_ShouldDeleteNewTask()
        {
            var newTask     = new WrikeTask("Test Task #4");
            var createdTask = WrikeClientFactory.GetWrikeClient().Tasks.CreateAsync(FolderId, newTask).Result;

            WrikeClientFactory.GetWrikeClient().Tasks.DeleteAsync(createdTask.Id).Wait();

            var tasks         = WrikeClientFactory.GetWrikeClient().Tasks.GetAsync().Result;
            var isTaskDeleted = !tasks.Any(t => t.Id == createdTask.Id);

            Assert.IsTrue(isTaskDeleted);
        }
Esempio n. 4
0
        public void UpdateAsync_ShouldUpdateTaskTitle()
        {
            var newTask = new WrikeTask("Test Task #3");

            newTask = WrikeClientFactory.GetWrikeClient().Tasks.CreateAsync(PersonalFolderId, newTask).Result;

            var expectedTaskTitle = "Test Task #3 [Updated]";
            var updatedTask       = WrikeClientFactory.GetWrikeClient().Tasks.UpdateAsync(newTask.Id, expectedTaskTitle).Result;

            Assert.IsNotNull(updatedTask);
            Assert.AreEqual(expectedTaskTitle, updatedTask.Title);
        }
Esempio n. 5
0
        async Task <WrikeTask> IWrikeTasksClient.CreateAsync(WrikeClientIdParameter folderId, WrikeTask newTask, string priorityBefore, string priorityAfter)
        {
            if (newTask == null)
            {
                throw new ArgumentNullException(nameof(newTask));
            }

            var postDataBuilder = new WrikeFormUrlEncodedContentBuilder()
                                  .AddParameter("title", newTask.Title)
                                  .AddParameter("description", newTask.Description)
                                  .AddParameter("importance", newTask.Importance)
                                  .AddParameter("dates", newTask.Dates)
                                  .AddParameter("shareds", newTask.SharedIds)
                                  .AddParameter("parents", newTask.ParentIds)
                                  .AddParameter("responsibles", newTask.ResponsibleIds)
                                  .AddParameter("followers", newTask.FollowerIds)
                                  .AddParameter("follow", newTask.FollowedByMe)
                                  .AddParameter("priorityBefore", priorityBefore)
                                  .AddParameter("priorityAfter", priorityAfter)
                                  .AddParameter("superTasks", newTask.SuperTaskIds)
                                  .AddParameter("metadata", newTask.Metadata)
                                  .AddParameter("customFields", newTask.CustomFields);

            if (string.IsNullOrWhiteSpace(newTask.CustomStatusId))
            {
                postDataBuilder.AddParameter("status", newTask.Status);
            }
            else
            {
                postDataBuilder.AddParameter("customStatus", newTask.CustomStatusId);
            }

            var response = await SendRequest <WrikeTask>($"folders/{folderId}/tasks", HttpMethods.Post, postDataBuilder.GetContent()).ConfigureAwait(false);

            return(GetReponseDataFirstItem(response));
        }
        public static async Task Run(WrikeClient client)
        {
            var tasks = await client.Tasks.GetAsync();

            var dueDate = DateTime.Now.AddDays(1);
            var newTask = new WrikeTask($"Due Date Should Be {dueDate.ToString("yyyy-MM-dd")}", dates: new WrikeTaskDate {
                Due = dueDate
            });

            newTask = await client.Tasks.CreateAsync("IEACGXLUI4IEQ6NG", newTask);



            //many other optional parameters
            //var tasks = await client.Tasks.GetAsync(
            //    createdDate: new WrikeDateFilterRange(new DateTime(2018, 1, 1), new DateTime(2018, 2, 5)),
            //    sortOrder: WrikeSortOrder.Asc,
            //    sortField: WrikeTaskSortField.CreatedDate,
            //    scheduledDate: new WrikeDateFilterRange(new DateTime(2018, 1, 1), new DateTime(2018, 2, 5)),
            //    dueDate: new WrikeDateFilterEqual(new DateTime(2018, 2, 5)),
            //    limit: 10
            //    );

            //tasks = await client.Tasks.GetAsync(accountId: "accountId");

            //tasks = await client.Tasks.GetAsync(folderId: "folderId");

            //tasks = await client.Tasks.GetAsync(new List<string> { "taskId", "taskId" });

            //tasks = await client.Tasks.GetAsync(
            //    new List<string> { "taskId", "taskId" },
            //    new List<string> {
            //        WrikeTask.OptionalFields.AttachmentCount,
            //        WrikeTask.OptionalFields.Recurrent }
            //    );

            //var tasks = await client.Tasks.GetAsync();


            //paged example
            var pagedTaskList = await client.Tasks.GetAsync(pageSize : 20);

            //you can read this property only after first paged request, otherwise it is 0
            var responseSize = client.Tasks.LastResponseSize;
            //if you keep requesting with LastNextPageToken it will be empty when you get your last tasks of paged response
            var nextPageToken = client.Tasks.LastNextPageToken;

            while (!string.IsNullOrWhiteSpace(nextPageToken))
            {
                pagedTaskList = await client.Tasks.GetAsync(nextPageToken : nextPageToken);

                nextPageToken = client.Tasks.LastNextPageToken;
                //client.Tasks.LastResponseSize is zero here
            }

            //another paged example
            do
            {
                var pagedList2 = await client.Tasks.GetAsync(nextPageToken : client.Tasks.LastNextPageToken, pageSize : 20);
            } while (!string.IsNullOrWhiteSpace(client.Tasks.LastNextPageToken));


            //var newTask = new WrikeTask
            //{
            //    Title = "new task title",
            //    Description = "new task description",
            //    Status = WrikeTaskStatus.Active,
            //    Importance = WrikeTaskImportance.High,
            //    Dates = new WrikeTaskDate
            //    {
            //        Due = DateTime.Now.AddDays(5),
            //        Duration = 180000,
            //        Start = DateTime.Now,
            //        Type = WrikeTaskDateType.Planned,
            //        WorkOnWeekends = false

            //    },
            //    SharedIds = null,
            //    ParentIds = null,
            //    ResponsibleIds = null,
            //    FollowerIds = null,
            //    FollowedByMe = false,
            //    SuperTaskIds = null,
            //    Metadata = new List<WrikeMetadata> {
            //        new WrikeMetadata("metadata1","metadata1.value")
            //    },
            //    CustomStatusId = null
            //};
            //newTask = await client.Tasks.CreateAsync("folderId", newTask);

            //tasks = await client.Tasks.GetAsync();

            //newTask = await client.Tasks.UpdateAsync(
            //    newTask.Id,
            //    title: "updated task title",
            //    description: "updated description");

            //var deletedTask = await client.Tasks.DeleteAsync(newTask.Id);

            //tasks = await client.Tasks.GetAsync();
        }