This Gist repository contains code snippet related to Aspose.Tasks Cloud SDK for .NET

Aspose.Tasks-Cloud-SDK-NET

Aspose.Tasks-Cloud-SDK-NET

Examples-CreateNewProjectByLoginPassword.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.CreateNewProjectAsync(new CreateNewProjectRequest()
{
    Name = remoteName,
    UserName = "SomeLogin",
    XSharepointPassword = "SomePassword",
    SiteUrl = "http://project_server_instance.local/sites/pwa"
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-CreateNewProjectByToken.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.CreateNewProjectAsync(new CreateNewProjectRequest()
{
    Name = remoteName,
    XProjectOnlineToken = "SOMESECRETTOKEN",
    SiteUrl = "http://project_server_instance.local/sites/pwa"
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-DeleteAssignment.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.DeleteAssignmentAsync(new DeleteAssignmentRequest
{
    AssignmentUid = 63,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-DeleteCalendar.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("CalendarWorkWeeks.mpp");

var response = await TasksApi.DeleteCalendarAsync(new DeleteCalendarRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    CalendarUid = 3
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-DeleteCalendarException.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Calenar with exception.mpp");

var response = await TasksApi.DeleteCalendarExceptionAsync(new DeleteCalendarExceptionRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    CalendarUid = 1,
    Index = 1
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-DeleteExtendedAttributeByIndex.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var deleteResponse = await TasksApi.DeleteExtendedAttributeByIndexAsync(new DeleteExtendedAttributeByIndexRequest
{
    Index = 1,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, deleteResponse.Code);

Examples-DeleteOutlineCodeByIndex.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.DeleteOutlineCodeByIndexAsync(new DeleteOutlineCodeByIndexRequest
{
    Index = 1,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-DeleteResource.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var deleteResponse = await TasksApi.DeleteResourceAsync(new DeleteResourceRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    ResourceUid = 0
});

Assert.AreEqual((int)HttpStatusCode.OK, deleteResponse.Code);

Examples-DeleteTask.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Project2016.mpp");

var deleteResponse = await TasksApi.DeleteTaskAsync(new DeleteTaskRequest
{
    TaskUid = 4,
    Name = remoteName,
    Folder = this.DataFolder,
    FileName = remoteName
});

Assert.AreEqual((int)HttpStatusCode.OK, deleteResponse.Code);

var tasksResponse = await TasksApi.GetTasksAsync(new GetTasksRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, tasksResponse.Code);
Assert.IsNotNull(tasksResponse.Tasks);

Examples-DeleteTaskLink.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var deleteResponse = await TasksApi.DeleteTaskLinkAsync(new DeleteTaskLinkRequest()
{
    Index = 1,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, deleteResponse.Code);

var linksResponse = await TasksApi.GetTaskLinksAsync(new GetTaskLinksRequest()
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, linksResponse.Code);
Assert.IsNotNull(linksResponse.TaskLinks);
Assert.AreEqual(23, linksResponse.TaskLinks.Count);

Examples-GetAssignment.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.GetAssignmentAsync(new GetAssignmentRequest
{
    AssignmentUid = 63,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Assignment);
Assert.AreEqual(TimeSpan.FromHours(8), response.Assignment.RegularWork);
Assert.AreEqual(TimeSpan.FromHours(8), response.Assignment.RemainingWork);
Assert.AreEqual(new DateTime(2012, 7, 9, 8, 0, 0), response.Assignment.Start.Value);

Examples-GetAssignments.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.GetAssignmentsAsync(new GetAssignmentsRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});
Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Assignments);
Assert.AreEqual(6, response.Assignments.AssignmentItem.Count);
Assert.AreEqual(34, response.Assignments.AssignmentItem[0].TaskUid);
Assert.AreEqual(63, response.Assignments.AssignmentItem[0].Uid);
Assert.AreEqual("/63", response.Assignments.AssignmentItem[0].Link.Href);

Examples-GetAssignmentTimephasedData.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.GetAssignmentTimephasedDataAsync(new GetAssignmentTimephasedDataRequest()
{
    AssignmentUid = 66,
    Name = remoteName,
    Folder = this.DataFolder,
    Type = TimephasedDataType.AssignmentWork
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Items);
var timephasedDataItems = response.Items;
Assert.IsNotNull(timephasedDataItems);
Assert.IsTrue(timephasedDataItems.Count > 0);

for (int i = 0; i < timephasedDataItems.Count; i++)
{
    Assert.AreEqual(TimephasedDataType.AssignmentWork, timephasedDataItems[i].TimephasedDataType);
    Assert.AreEqual(66, timephasedDataItems[i].Uid);
}

Examples-GetCalendar.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.GetCalendarAsync(new GetCalendarRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    CalendarUid = 1
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Calendar);
Assert.AreEqual("Standard", response.Calendar.Name);
Assert.AreEqual(1, response.Calendar.Uid);
Assert.AreEqual(true, response.Calendar.IsBaseCalendar);
Assert.AreEqual(false, response.Calendar.IsBaselineCalendar);
Assert.AreEqual(7, response.Calendar.Days.Count);

Examples-GetCalendarExceptions.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Calenar with exception.mpp");

var getResponse = await TasksApi.GetCalendarExceptionsAsync(new GetCalendarExceptionsRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    CalendarUid = 1
});

Assert.AreEqual((int)HttpStatusCode.OK, getResponse.Code);
Assert.IsNotNull(getResponse.CalendarExceptions);
Assert.AreEqual(1, getResponse.CalendarExceptions.Count);

var calendarException = getResponse.CalendarExceptions[0];
Assert.AreEqual(true, calendarException.DayWorking);
CollectionAssert.AreEqual(new[] { DayType.Monday }, calendarException.DaysOfWeek);
Assert.AreEqual(new DateTime(2018, 02, 13), calendarException.FromDate);
Assert.AreEqual(new DateTime(2018, 04, 9), calendarException.ToDate.Value.Date);

Assert.AreEqual(Month.Undefined, calendarException.Month);
Assert.AreEqual(MonthItemType.Undefined, calendarException.MonthItem);
Assert.AreEqual(MonthPosition.Undefined, calendarException.MonthPosition);
Assert.AreEqual(CalendarExceptionType.Weekly, calendarException.Type);
Assert.AreEqual(8, calendarException.Occurrences);
Assert.AreEqual(1, calendarException.Period);
Assert.AreEqual(2, calendarException.WorkingTimes.Count);
Assert.AreEqual(TimeSpan.FromHours(9), calendarException.WorkingTimes[0].FromTime.Value.TimeOfDay);
Assert.AreEqual(new TimeSpan(12, 34, 0), calendarException.WorkingTimes[0].ToTime.Value.TimeOfDay);
Assert.AreEqual(new TimeSpan(15, 11, 0), calendarException.WorkingTimes[1].FromTime.Value.TimeOfDay);
Assert.AreEqual(new TimeSpan(17, 30, 0), calendarException.WorkingTimes[1].ToTime.Value.TimeOfDay);

Examples-GetCalendars.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.GetCalendarsAsync(new GetCalendarsRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.AreEqual(1, response.Calendars.List.Count);
Assert.AreEqual("Standard", response.Calendars.List[0].Name);
Assert.AreEqual(1L, response.Calendars.List[0].Uid);

Examples-GetCalendarWorkWeeks.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
 var remoteName = await UploadFileToStorageAsync("CalendarWorkWeeks.mpp");

var calendarsReponse = await TasksApi.GetCalendarsAsync(new GetCalendarsRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, calendarsReponse.Code);
Assert.IsNotNull(calendarsReponse.Calendars);

var calendarUid = calendarsReponse.Calendars.List.Where(c => c.Name == "Test work weeks").
    Select(c => c.Uid)
    .FirstOrDefault();

var getResponse = await TasksApi.GetCalendarWorkWeeksAsync(new GetCalendarWorkWeeksRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    CalendarUid = calendarUid
});

Assert.AreEqual((int)HttpStatusCode.OK, getResponse.Code);
Assert.IsNotNull(getResponse.CalendarWorkWeeks);

Assert.AreEqual(1, getResponse.CalendarWorkWeeks.Count);
var workWeek = getResponse.CalendarWorkWeeks[0];

Assert.AreEqual("Work week 1", workWeek.Name);
Assert.AreEqual(new DateTime(2018, 1, 1), workWeek.FromDate.Value.Date);
Assert.AreEqual(new DateTime(2018, 1, 7), workWeek.ToDate.Value.Date);

Assert.AreEqual(4, workWeek.WeekDays.Count);
Assert.AreEqual(true, workWeek.WeekDays[0].DayWorking);
Assert.AreEqual(DayType.Monday, workWeek.WeekDays[0].DayType);
Assert.AreEqual(1, workWeek.WeekDays[0].WorkingTimes.Count);
Assert.AreEqual(new TimeSpan(11, 30, 0), workWeek.WeekDays[0].WorkingTimes[0].FromTime.Value.TimeOfDay);
Assert.AreEqual(new TimeSpan(12, 30, 0), workWeek.WeekDays[0].WorkingTimes[0].ToTime.Value.TimeOfDay);

Assert.AreEqual(false, workWeek.WeekDays[1].DayWorking);
Assert.AreEqual(DayType.Tuesday, workWeek.WeekDays[1].DayType);
Assert.AreEqual(0, workWeek.WeekDays[1].WorkingTimes.Count);

Assert.AreEqual(true, workWeek.WeekDays[2].DayWorking);
Assert.AreEqual(DayType.Wednesday, workWeek.WeekDays[2].DayType);
Assert.AreEqual(2, workWeek.WeekDays[2].WorkingTimes.Count);

Assert.AreEqual(new TimeSpan(9, 30, 0), workWeek.WeekDays[2].WorkingTimes[0].FromTime.Value.TimeOfDay);
Assert.AreEqual(new TimeSpan(13, 23, 0), workWeek.WeekDays[2].WorkingTimes[0].ToTime.Value.TimeOfDay);
Assert.AreEqual(new TimeSpan(14, 45, 0), workWeek.WeekDays[2].WorkingTimes[1].FromTime.Value.TimeOfDay);
Assert.AreEqual(new TimeSpan(18, 45, 0), workWeek.WeekDays[2].WorkingTimes[1].ToTime.Value.TimeOfDay);

Assert.AreEqual(true, workWeek.WeekDays[3].DayWorking);
Assert.AreEqual(DayType.Saturday, workWeek.WeekDays[3].DayType);
Assert.AreEqual(1, workWeek.WeekDays[3].WorkingTimes.Count);

Assert.AreEqual(new TimeSpan(9, 0, 0), workWeek.WeekDays[3].WorkingTimes[0].FromTime.Value.TimeOfDay);
Assert.AreEqual(new TimeSpan(10, 0, 0), workWeek.WeekDays[3].WorkingTimes[0].ToTime.Value.TimeOfDay);

Examples-GetDocumentProperties.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.GetDocumentPropertiesAsync(new GetDocumentPropertiesRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.AreEqual(52, response.Properties.List.Count);
Assert.AreEqual("Title", response.Properties.List[0].Name);
Assert.AreEqual("Home Move", response.Properties.List[0].Value);

Examples-GetDocumentProperty.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.GetDocumentPropertyAsync(new GetDocumentPropertyRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    PropertyName = "Title"
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Property);
Assert.AreEqual("Title", response.Property.Name);
Assert.AreEqual("Home Move", response.Property.Value);

Examples-GetExtendedAttributeByIndex.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.GetExtendedAttributeByIndexAsync(new GetExtendedAttributeByIndexRequest
{
    Index = 1,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.ExtendedAttribute);
Assert.AreEqual("Text1", response.ExtendedAttribute.FieldName);
Assert.AreEqual(CalculationType.Lookup, response.ExtendedAttribute.CalculationType);
Assert.AreEqual(1, response.ExtendedAttribute.ValueList.Count);
Assert.AreEqual("descr", response.ExtendedAttribute.ValueList[0].Description);
Assert.AreEqual(1, response.ExtendedAttribute.ValueList[0].Id);

Examples-GetExtendedAttributes.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.GetExtendedAttributesAsync(new GetExtendedAttributesRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.ExtendedAttributes);
Assert.AreEqual(2, response.ExtendedAttributes.List.Count);

Examples-GetOutlineCodeByIndex.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.GetOutlineCodeByIndexAsync(new GetOutlineCodeByIndexRequest
{
    Index = 1,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.OutlineCode);
Assert.AreEqual("F45D601B-70C5-E311-A5BA-D43D7E937F92", response.OutlineCode.Guid);

Examples-GetOutlineCodes.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.GetOutlineCodesAsync(new GetOutlineCodesRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.OutlineCodes);
Assert.AreEqual(2, response.OutlineCodes.List.Count);

Examples-GetPageCount.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.GetPageCountAsync(new GetPageCountRequest
{
    PresentationFormat = PresentationFormat.TaskUsage,
    Timescale = Timescale.Months,
    Name = remoteName,
    Folder = this.DataFolder,
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.AreEqual(4, response.PageCount);

Examples-GetProjectIds.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("p6_multiproject.xml");

var response = await TasksApi.GetProjectIdsAsync(new GetProjectIdsRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
CollectionAssert.AreEquivalent(new string[] { "1", "111" } , response.ProjectIds);

Examples-GetProjectListByLoginPassword.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var response = await TasksApi.GetProjectListAsync(new GetProjectListRequest
{
    UserName = "SomeLogin",
    XSharepointPassword = "SomePassword",
    SiteUrl = "http://project_server_instance.local/sites/pwa"
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.That(response.Projects, Is.Not.Empty);

Examples-GetProjectListByToken.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var response = await TasksApi.GetProjectListAsync(new GetProjectListRequest
{
    Token = "SOMESECRETTOKEN",
    SiteUrl = "http://project_server_instance.local/sites/pwa"
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.That(response.Projects, Is.Not.Empty);

Examples-GetReportPdf.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");
var response = await TasksApi.GetReportPdfAsync(new GetReportPdfRequest()
{ 
    Type = ReportType.Milestones,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.IsTrue(response.Length > 0);
var buffer = new byte[4];
response.Read(buffer, 0, 4);
Assert.AreEqual("%PDF", Encoding.ASCII.GetString(buffer));

Examples-GetResourceAssignments.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.GetResourceAssignmentsAsync(new GetResourceAssignmentsRequest
{
    ResourceUid = 1,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Assignments);
Assert.AreEqual(6, response.Assignments.List.Count);
Assert.IsTrue(response.Assignments.List.All(a => a.ResourceUid == 1));

Examples-GetResources.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var resourceResponse = await TasksApi.GetResourcesAsync(new GetResourcesRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, resourceResponse.Code);
Assert.IsNotNull(resourceResponse.Resources);
Assert.AreEqual(2, resourceResponse.Resources.ResourceItem.Count);
Assert.AreEqual("Project manager", resourceResponse.Resources.ResourceItem[1].Name);
Assert.AreEqual(1, resourceResponse.Resources.ResourceItem[1].Uid);
Assert.AreEqual(1, resourceResponse.Resources.ResourceItem[1].Id);

Examples-GetResourceTimephasedData.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.GetResourceTimephasedDataAsync(new GetResourceTimephasedDataRequest()
{
    ResourceUid = 1,
    Name = remoteName,
    Folder = this.DataFolder,
    Type = TimephasedDataType.ResourceWork,
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Items);
var timephasedDataItems = response.Items;
Assert.IsNotNull(timephasedDataItems);
Assert.IsTrue(timephasedDataItems.Count > 0);

for (int i = 0; i < timephasedDataItems.Count; i++)
{
    Assert.AreEqual(TimephasedDataType.ResourceWork, timephasedDataItems[i].TimephasedDataType);
    Assert.AreEqual(1, timephasedDataItems[i].Uid);
}

Examples-GetTask.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Project2016.mpp");

var tasksResponse = await TasksApi.GetTaskAsync(new GetTaskRequest
{
    TaskUid = 5,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, tasksResponse.Code);
Assert.IsNotNull(tasksResponse.Task);
Assert.AreEqual(5, tasksResponse.Task.Uid);
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4 }, tasksResponse.Task.SubtasksUids);
Assert.AreEqual(new DateTime(2015, 8, 3, 8, 0, 0), tasksResponse.Task.Start);
Assert.AreEqual(new DateTime(2015, 8, 6, 17, 0, 0), tasksResponse.Task.Finish);
Assert.AreEqual(new TimeSpan(1, 8, 0, 0, 0), tasksResponse.Task.RemainingWork);
Assert.AreEqual(1920, tasksResponse.Task.WorkVariance);

Examples-GetTaskAssignments.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.GetTaskAssignmentsAsync(new GetTaskAssignmentsRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    TaskUid = 1
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Assignments);

Examples-GetTaskDocumentWithFormat.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.GetTaskDocumentWithFormatAsync(new GetTaskDocumentWithFormatRequest
{
    Format = ProjectFileFormat.Csv,
    Name = remoteName,
    Folder = this.DataFolder,
});

Assert.IsNotNull(response);
Assert.IsTrue(response.Length > 0);
response.Seek(0, SeekOrigin.Begin);

using (var sr = new StreamReader(response))
{
    var headersLine = sr.ReadLine();

    var line1 = sr.ReadLine();
    Assert.AreEqual("ID;Task_Name;Outline_Level;Duration;Start_Date;Finish_Date;Percent_Comp;Cost;Work", headersLine);
    Assert.AreEqual("1;Five to Eight Weeks Before Moving;1;16 days;Thu 01.01.04 08:00;Thu 22.01.04 17:00;0%;$0;0 hrs", line1);
}

Examples-GetTaskLinks.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.GetTaskLinksAsync(new GetTaskLinksRequest()
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.TaskLinks);
Assert.AreEqual(24, response.TaskLinks.Count);

Examples-GetTaskRecurringInfo.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("sample.mpp");

var response = await TasksApi.GetTaskRecurringInfoAsync(new GetTaskRecurringInfoRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    TaskUid = 6
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.RecurringInfo);

var entity = response.RecurringInfo;
Assert.AreEqual(2, (int)entity.Occurrences);
Assert.AreEqual(RecurrencePattern.Monthly, entity.RecurrencePattern);
Assert.AreEqual(true, entity.UseEndDate);
Assert.AreEqual(false, entity.MonthlyUseOrdinalDay);
Assert.AreEqual(1, entity.MonthlyDay);
Assert.AreEqual(WeekDayType.None, entity.WeeklyDays);
Assert.AreEqual(OrdinalNumber.Second, entity.YearlyOrdinalNumber);

Examples-GetTasks.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Project2016.mpp");

var tasksResponse = await TasksApi.GetTasksAsync(new GetTasksRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, tasksResponse.Code);
Assert.IsNotNull(tasksResponse.Tasks);
Assert.AreEqual(6, tasksResponse.Tasks.TaskItem.Count);

var firstTask = tasksResponse.Tasks.TaskItem.FirstOrDefault(i => i.Uid == 5);
Assert.IsNotNull(firstTask);
Assert.AreEqual("Summary Task 1", firstTask.Name);
Assert.AreEqual(new DateTime(2015, 8, 3, 8, 0, 0), firstTask.Start);
Assert.AreEqual(new DateTime(2015, 8, 6, 17, 0, 0), firstTask.Finish);
Assert.AreEqual("/5", firstTask.Link.Href);

Examples-GetTaskTimephasedData.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.GetTaskTimephasedDataAsync(new GetTaskTimephasedDataRequest()
{
    TaskUid = 27,
    Name = remoteName,
    Folder = this.DataFolder,
    Type = TimephasedDataType.TaskWork
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Items);
var timephasedDataItems = response.Items;
Assert.IsNotNull(timephasedDataItems);
Assert.IsTrue(timephasedDataItems.Count > 0);

for (int i = 0; i < timephasedDataItems.Count; i++)
{
    Assert.AreEqual(TimephasedDataType.TaskWork, timephasedDataItems[i].TimephasedDataType);
    Assert.AreEqual(27, timephasedDataItems[i].Uid);
}

Examples-GetVbaProject.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("VbaProject3.mpp");
var vbaResponse = await TasksApi.GetVbaProjectAsync(new GetVbaProjectRequest()
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, vbaResponse.Code);
Assert.IsNotNull(vbaResponse.VbaProject);
Assert.IsNotNull(vbaResponse.VbaProject.Modules);

Assert.AreEqual(7, vbaResponse.VbaProject.Modules.Count);
Assert.AreEqual("Module1", vbaResponse.VbaProject.Modules[0].Name);
Assert.IsTrue(vbaResponse.VbaProject.Modules[0].SourceCode.StartsWith("Type MEMORYSTATUS"));

Examples-PostAssignment.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.PostAssignmentAsync(new PostAssignmentRequest
{
    ResourceUid = 1,
    Units = 0.5D,
    TaskUid = 0,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.AssignmentItem);

Examples-PostAssignmentWithCost.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Cost_Res.mpp");

var response = await TasksApi.PostAssignmentAsync(new PostAssignmentRequest
{
    ResourceUid = 1,
    Cost = 2,
    TaskUid = 0,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.AssignmentItem);

Examples-PostCalendar.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.PostCalendarAsync(new PostCalendarRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    Calendar = new Calendar
    {
        Name = "My new calendar",
        Days = new List<WeekDay>
        {
            new WeekDay { DayType = DayType.Sunday, DayWorking = false },
            new WeekDay { DayType = DayType.Monday, DayWorking = true, FromDate = DateTime.MinValue.Add(TimeSpan.FromHours(8)), ToDate = DateTime.MinValue.Add(TimeSpan.FromHours(17)),
                WorkingTimes = new List<WorkingTime>
                {
                    new WorkingTime { FromTime = DateTime.MinValue.Add(TimeSpan.FromHours(8)), ToTime = DateTime.MinValue.Add(TimeSpan.FromHours(13))},
                    new WorkingTime { FromTime = DateTime.MinValue.Add(TimeSpan.FromHours(14)), ToTime = DateTime.MinValue.Add(TimeSpan.FromHours(17))}
                }
            }
            },
        IsBaseCalendar = false,
        IsBaselineCalendar = false
    }
});

Assert.AreEqual((int)HttpStatusCode.Created, response.Code);

Examples-PostCalendarException.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("New project 2013.mpp");

var calendarException = new CalendarException
{
    Name = "Non-working day exception",
    DayWorking = false,
    FromDate = new DateTime(2014, 10, 28),
    ToDate = new DateTime(2015, 08, 5),
    Occurrences = 10,
    Type = CalendarExceptionType.MonthlyByDay,
    EnteredByOccurrences = true,
    MonthDay = 5,
    Period = 1
};

var response = await TasksApi.PostCalendarExceptionAsync(new PostCalendarExceptionRequest
{
    CalendarUid = 1,
    CalendarException = calendarException,
    Name = remoteName,
    Folder = this.DataFolder
});

Examples-PostDocumentProperty.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var putResponse = await TasksApi.PostDocumentPropertyAsync(new PostDocumentPropertyRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    PropertyName = "Title",
    Property = new DocumentProperty
    {
        Name = "Title",
        Value = "New title value"
    }
});

var response = await TasksApi.GetDocumentPropertiesAsync(new GetDocumentPropertiesRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.AreEqual(52, response.Properties.List.Count);
Assert.AreEqual("Title", response.Properties.List[0].Name);
Assert.AreEqual("New title value", response.Properties.List[0].Value);

Examples-PostDocumentPropertyNonExisting.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var postResponse = await TasksApi.PostDocumentPropertyAsync(new PostDocumentPropertyRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    PropertyName = "new property",
    Property = new DocumentProperty
    {
        Name = "new property",
        Value = "New property value"
    }
});

var response = await TasksApi.GetDocumentPropertiesAsync(new GetDocumentPropertiesRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.AreEqual(52, response.Properties.List.Count);
Assert.IsNull(response.Properties.List.Where(p => p.Name == "new property").FirstOrDefault());

Examples-PostResource.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var resourceResponse = await TasksApi.GetResourcesAsync(new GetResourcesRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, resourceResponse.Code);
var count = resourceResponse.Resources.ResourceItem.Count;

var postResponse = await TasksApi.PostResourceAsync(new PostResourceRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    ResourceName = "new resource"
});

Assert.AreEqual((int)HttpStatusCode.Created, postResponse.Code);

Examples-PostTask.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Project2016.mpp");

var postResponse = await TasksApi.PostTaskAsync(new PostTaskRequest
{
  BeforeTaskId = 4,
  TaskName = "New task name",
  Name = remoteName,
  Folder = this.DataFolder,
  FileName = remoteName
});

Assert.AreEqual((int)HttpStatusCode.Created, postResponse.Code);
Assert.IsNotNull(postResponse.TaskItem);

Examples-PostTaskDocumentWithFormat.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

// SaveOptions parameters is a json-serialized representation of 
// Aspose.Tasks's SaveOptions class or its format-specific inheritors (Like CsvOptions, etc):

var saveOptionsSerialized = "{ \"TextDelimiter\":\"Comma\", \"IncludeHeaders\":false,\"NonExistingTestProperty\":false," +
    "\"View\":{ \"Columns\":[{Type:\"GanttChartColumn\",\"Name\":\"TestColumn1\",\"Property\":\"Name\",\"Width\":120}," +
    "{Type:\"GanttChartColumn\",\"Name\":\"TestColumn2\",\"Property\":\"Duration\",\"Width\":120}]}}";

var saveOptions = JObject.Parse(saveOptionsSerialized);

var response = await TasksApi.PostTaskDocumentWithFormatAsync(new PostTaskDocumentWithFormatRequest
{
    Format = ProjectFileFormat.Csv,
    Name = remoteName,
    Folder = this.DataFolder,
    SaveOptions = saveOptions
});

Assert.IsNotNull(response);
Assert.IsTrue(response.Length > 0);
response.Seek(0, SeekOrigin.Begin);

using (var sr = new StreamReader(response))
{
    var line1 = sr.ReadLine();
    Assert.AreEqual("Five to Eight Weeks Before Moving,16 days", line1);
}

Examples-PostTaskLink.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.PostTaskLinkAsync(new PostTaskLinkRequest()
{
    TaskLink = new TaskLink
    {
        PredecessorUid = 28,
        SuccessorUid = 30,
        LinkType = TaskLinkType.StartToStart,
        Lag = 9600,
        LagFormat = TimeUnitType.Day
    },
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutAssignment.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.GetAssignmentAsync(new GetAssignmentRequest
{
    AssignmentUid = 63,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Assignment);

response.Assignment.TaskUid = 0;

var putResponse = await TasksApi.PutAssignmentAsync(new PutAssignmentRequest
{
    Mode = CalculationMode.Automatic,
    Recalculate = true,
    AssignmentUid = 63,
    Assignment = response.Assignment,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, putResponse.Code);

Examples-PutAssignmentTimePhasedData.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("sample.mpp");

var response = await TasksApi.GetAssignmentAsync(new GetAssignmentRequest
{
    AssignmentUid = 1,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.Assignment);

var assignment = response.Assignment;
assignment.Cost = 100;
assignment.Start = new DateTime(2001, 10, 10);
assignment.Finish = new DateTime(2002, 10, 10);
assignment.ActualWork = new TimeSpan(10, 10, 10);
assignment.ActualCost = 100;
assignment.ActualStart = new DateTime(2001, 10, 11);
assignment.ActualFinish = new DateTime(2002, 10, 11);
assignment.ActualOvertimeWork = new TimeSpan(100, 10, 0);
assignment.Work = new TimeSpan(80, 0, 0);
assignment.Uid = 1;
assignment.Vac = 10;
assignment.WorkContour = WorkContourType.Contoured;
assignment.TimephasedData.Clear();
assignment.TimephasedData.Add(new TD
{
    Uid = assignment.Uid,
    Start = new DateTime(2001, 10, 10, 9, 0, 0, 0),
    Finish = new DateTime(2001, 10, 10, 14, 0, 0, 0),
    Unit = TimeUnitType.Hour,
    Value = TimeSpan.FromHours(4).ToString(),
    TimephasedDataType = TimephasedDataType.AssignmentRemainingWork
});
assignment.Baselines.Add(new AssignmentBaseline
{
    BaselineNumber = BaselineType.Baseline1,
    Start = new DateTime(2002, 10, 10)
});

var putResponse = await TasksApi.PutAssignmentAsync(new PutAssignmentRequest
{
    Mode = CalculationMode.None,
    Recalculate = false,
    AssignmentUid = assignment.Uid,
    Assignment = assignment,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual(HttpStatusCode.OK.ToString(), putResponse.Status);
Assert.IsNotNull(putResponse.Assignment);
var assignmentAfterUpdate = putResponse.Assignment;
var baselinesAfterUpdate = assignmentAfterUpdate.Baselines;
Assert.AreEqual(1, baselinesAfterUpdate.Count);
Assert.AreEqual(BaselineType.Baseline1, baselinesAfterUpdate[0].BaselineNumber);
Assert.AreEqual(assignment.Baselines[0].Start, baselinesAfterUpdate[0].Start);

var timephasedDataAfterUpdate = assignmentAfterUpdate.TimephasedData;
var td = timephasedDataAfterUpdate[0];
Assert.AreEqual(1, timephasedDataAfterUpdate.Count);
Assert.AreEqual(assignment.TimephasedData[0].Uid, td.Uid);
Assert.AreEqual(assignment.TimephasedData[0].Start, td.Start);
Assert.AreEqual(assignment.TimephasedData[0].Finish, td.Finish);
Assert.AreEqual(assignment.TimephasedData[0].Unit, td.Unit);
Assert.AreEqual("PT4H0M0S", td.Value.ToString());
Assert.AreEqual(assignment.TimephasedData[0].TimephasedDataType, td.TimephasedDataType);

Assert.AreEqual(assignment.Cost, assignmentAfterUpdate.Cost);
Assert.AreEqual(assignment.Start, assignmentAfterUpdate.Start);
Assert.AreEqual(assignment.Finish, assignmentAfterUpdate.Finish);
Assert.AreEqual(assignment.Work, assignmentAfterUpdate.Work);
Assert.AreEqual(assignment.ActualWork, assignmentAfterUpdate.ActualWork);
Assert.AreEqual(assignment.ActualStart, assignmentAfterUpdate.ActualStart);
Assert.AreEqual(assignment.ActualFinish, assignmentAfterUpdate.ActualFinish);
Assert.AreEqual(assignment.ActualOvertimeWork, assignmentAfterUpdate.ActualOvertimeWork);
Assert.AreEqual(assignment.Vac, assignmentAfterUpdate.Vac);
Assert.AreEqual(assignment.Uid, assignmentAfterUpdate.Uid);

Examples-PutCalendar.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.PutCalendarAsync(new PutCalendarRequest
{
    CalendarUid = 1,
    Name = remoteName,
    Folder = this.DataFolder,
    Calendar = new Calendar
    {
        Uid = 1,
        Name = "Modified calendar",
        Days = new List<WeekDay>
        {
            new WeekDay { DayType = DayType.Sunday, DayWorking = false },
            new WeekDay { DayType = DayType.Monday, DayWorking = true, FromDate = DateTime.MinValue.Add(TimeSpan.FromHours(8)), ToDate = DateTime.MinValue.Add(TimeSpan.FromHours(17)),
                WorkingTimes = new List<WorkingTime>
                {
                    new WorkingTime { FromTime = DateTime.MinValue.Add(TimeSpan.FromHours(8)), ToTime = DateTime.MinValue.Add(TimeSpan.FromHours(13))},
                    new WorkingTime { FromTime = DateTime.MinValue.Add(TimeSpan.FromHours(14)), ToTime = DateTime.MinValue.Add(TimeSpan.FromHours(17))}
                }
            }
            },
        IsBaseCalendar = false,
        IsBaselineCalendar = false
    }
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutCalendarException.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Calenar with exception.mpp");

var getResponse = await TasksApi.GetCalendarExceptionsAsync(new GetCalendarExceptionsRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    CalendarUid = 1
});

Assert.AreEqual((int)HttpStatusCode.OK, getResponse.Code);

var calendarException = getResponse.CalendarExceptions[0];

calendarException.DaysOfWeek = new List<DayType> { DayType.Thursday, DayType.Friday };
calendarException.WorkingTimes = new List<WorkingTime> { new WorkingTime() { FromTime = DateTime.MinValue + TimeSpan.FromHours(9), ToTime = DateTime.MinValue + TimeSpan.FromHours(17) } };
calendarException.Occurrences = 10;
calendarException.EnteredByOccurrences = true;
calendarException.Period = 1;
calendarException.Name = "Non-working day exception";
calendarException.DayWorking = true;
calendarException.FromDate = new DateTime(2014, 10, 28);
calendarException.ToDate = new DateTime(2015, 08, 5);

var response = await TasksApi.PutCalendarExceptionAsync(new PutCalendarExceptionRequest
{
    CalendarUid = 1,
    Index = calendarException.Index,
    CalendarException = calendarException,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutDocumentProperty.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var putResponse = await TasksApi.PutDocumentPropertyAsync(new PutDocumentPropertyRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    PropertyName = "Title",
    Property = new DocumentProperty
    {
        Name = "Title", 
        Value = "New title value"
    }
});

var response = await TasksApi.GetDocumentPropertiesAsync(new GetDocumentPropertiesRequest
{
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.AreEqual(52, response.Properties.List.Count);
Assert.AreEqual("Title", response.Properties.List[0].Name);
Assert.AreEqual("New title value", response.Properties.List[0].Value);

Examples-PutExtendedAttribute.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var newExtendedAttribute = new ExtendedAttributeDefinition
{
    CalculationType = CalculationType.Lookup,
    CfType = CustomFieldType.Text,
    FieldName = "Text3",
    ElementType = ElementType.Task,
    Alias = "New Field",
    ValueList = new List<Value>
    {
        new Value { Description = "descr1", Val = "Internal", Id = 111 },
        new Value { Description = "descr2", Val = "External", Id = 112 }
    }
};

var response = await TasksApi.PutExtendedAttributeAsync(new PutExtendedAttributeRequest
{
    ExtendedAttribute = newExtendedAttribute,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);
Assert.IsNotNull(response.ExtendedAttribute);

Assert.AreEqual("Text3", response.ExtendedAttribute.FieldName);
Assert.AreEqual("New Field", response.ExtendedAttribute.Alias);
Assert.AreEqual("188743737", response.ExtendedAttribute.FieldId);

Examples-PutImportProjectFromDb.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var response = await TasksApi.PutImportProjectFromDbAsync(new PutImportProjectFromDbRequest
{
    ConnectionString = "Data Source=db.contoso.com;Initial Catalog=ProjectServer;Persist Security Info=True;User ID=sa;Password=pwd;",
    DatabaseType = ProjectDatabaseType.Msp,
    Folder = this.DataFolder,
    Filename = "imported_from_db.xml",
    ProjectUid = "E6426C44-D6CB-4B9C-AF16-48910ACE0F54",
    DatabaseSchema = "dbo",
    Format = ProjectFileFormat.P6xml
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutImportProjectFromFile.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remote = await UploadFileToStorageAsync("p6_multiproject.xml");

var response = await TasksApi.PutImportProjectFromFileAsync(new PutImportProjectFromFileRequest
{
    Name = remote,
    Folder = this.DataFolder,
    Filename = "imported_from_primavera.xml",
    ProjectUid = "111",
    FileType = ImportedProjectType.PrimaveraXml,
    OutputFileFormat = ProjectFileFormat.P6xml
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutImportProjectFromProjectByToken.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var fileName = "NewProductDev.mpp";
var getFileRequest = new DownloadFileRequest
{
    Path = fileName
};
var importFileRequest = new PutImportProjectFromProjectOnlineRequest
{
    Name = fileName,
    Guid = Guid.Parse("E6426C44-D6CB-4B9C-AF16-48910ACE0F54"),
    Token = "SOMESECRETTOKEN",
    SiteUrl = "http://project_server_instance.local/sites/pwa",
    Format = ProjectFileFormat.Xml
};
Stream binaryResponse = null;

var exception = Assert.ThrowsAsync<ApiException>(async () => binaryResponse = await TasksApi.DownloadFileAsync(getFileRequest));
Assert.AreEqual(HttpStatusCode.NotFound, exception.HttpStatusCode); 

var response = await TasksApi.PutImportProjectFromProjectOnlineAsync(importFileRequest);
Assert.AreEqual(HttpStatusCode.OK.ToString(), (string)response.Status);

Assert.DoesNotThrowAsync(async () => binaryResponse = await TasksApi.DownloadFileAsync(getFileRequest));
Assert.That(binaryResponse, Is.Not.Null);

binaryResponse.Dispose();
await TasksApi.DeleteFileAsync((new DeleteRequest(fileName)));

Examples-PutImportProjectFromProjectOnlineByLoginPassword.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var fileName = "NewProductDev.mpp";
var getFileRequest = new DownloadFileRequest
{
    Path = fileName
};
var importFileRequest = new PutImportProjectFromProjectOnlineRequest
{
    Name = fileName,
    Guid = Guid.Parse("E6426C44-D6CB-4B9C-AF16-48910ACE0F54"),
    UserName = "SomeLogin",
    XSharepointPassword = "SomePassword",
    SiteUrl = "http://project_server_instance.local/sites/pwa",
    Format = ProjectFileFormat.Xml
};
Stream binaryResponse = null;

var exception = Assert.ThrowsAsync<ApiException>(async () => binaryResponse = await TasksApi.DownloadFileAsync(getFileRequest));
Assert.AreEqual(HttpStatusCode.NotFound, exception.HttpStatusCode); 

var response = await TasksApi.PutImportProjectFromProjectOnlineAsync(importFileRequest);
Assert.AreEqual(HttpStatusCode.OK.ToString(), (string)response.Status);

Assert.DoesNotThrowAsync(async () => binaryResponse = await TasksApi.DownloadFileAsync(getFileRequest));
Assert.That(binaryResponse, Is.Not.Null);

binaryResponse.Dispose();
await TasksApi.DeleteFileAsync((new DeleteRequest(fileName)));

Examples-PutMoveTask.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("sample.mpp");

var getResponse = await TasksApi.GetTaskAsync(new GetTaskRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    TaskUid = 6
});

Assert.AreEqual((int)HttpStatusCode.OK, getResponse.Code);
CollectionAssert.DoesNotContain(getResponse.Task.SubtasksUids, 10);

var response = await TasksApi.PutMoveTaskAsync(new PutMoveTaskRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    ParentTaskUid = 6,
    TaskUid = 10
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutMoveTaskToSibling.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var response = await TasksApi.PutMoveTaskToSiblingAsync(new PutMoveTaskToSiblingRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    TaskUid = 41,
    BeforeTaskUid = 40
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutRecalculateProject.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("sample.mpp");
var recalculationResponse = await TasksApi.PutRecalculateProjectAsync(new PutRecalculateProjectRequest()
{
    FileName = remoteName,
    Folder = this.DataFolder,
    Name = remoteName,
    Mode = CalculationMode.None,
    Validate = true
});

Assert.AreEqual((int)HttpStatusCode.OK, recalculationResponse.Code);
var validationResult = recalculationResponse.Result;
Assert.AreEqual(ProjectValidationState.Valid, validationResult.ValidationState);

Examples-PutRecalculateProjectResourceFields.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.PutRecalculateProjectResourceFieldsAsync(new PutRecalculateProjectResourceFieldsRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutRecalculateProjectUncompleteWorkToStartAfter.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.PutRecalculateProjectUncompleteWorkToStartAfterAsync(new PutRecalculateProjectUncompleteWorkToStartAfterRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    After = new DateTime(2010, 10, 10)
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutRecalculateProjectWorkAsComplete.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Home move plan.mpp");

var response = await TasksApi.PutRecalculateProjectWorkAsCompleteAsync(new PutRecalculateProjectWorkAsCompleteRequest
{
    Name = remoteName,
    Folder = this.DataFolder,
    CompleteThrough = new DateTime(2010, 10, 10)
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-PutResource.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("sample.mpp");

var resourceResponse = await TasksApi.GetResourceAsync(new GetResourceRequest
{
	Name = remoteName,
	Folder = this.DataFolder,
	ResourceUid = 1
});

Assert.AreEqual((int)HttpStatusCode.OK, resourceResponse.Code);
Assert.IsNotNull(resourceResponse.Resource);

var resource = resourceResponse.Resource;
resource.Name = "Modified Resource1";
resource.Cost = 200;
resource.Start = new DateTime(2000, 10, 10);
resource.Work = new TimeSpan(100, 10, 0);
resource.Finish = new DateTime(2000, 10, 10);
resource.OvertimeWork = new TimeSpan(100, 0, 0);
resource.StandardRate = 101;
resource.Baselines.Add(new Model.Baseline
{
	BaselineNumber = Model.BaselineType.Baseline1,
	Cost = 44,
});

var putResponse = await TasksApi.PutResourceAsync(new PutResourceRequest
{
	Name = remoteName,
	Folder = this.DataFolder,
	ResourceUid = 1,
	Resource = resource,
	Recalculate = false,
	Mode = Model.CalculationMode.None
});

Assert.AreEqual((int)HttpStatusCode.OK, putResponse.Code);

Examples-PutTask.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("Project2016.mpp");

var getResponse = await TasksApi.GetTaskAsync(new GetTaskRequest
{
    TaskUid = 4,
    Name = remoteName,
    Folder = this.DataFolder,
});

var task = getResponse.Task;
task.Name = "Modified task name";
task.IsManual = true;
task.ManualStart = new DateTime(2015, 10, 1, 9, 15, 0);
task.ManualFinish = new DateTime(2015, 10, 1, 17, 15, 0);

var putResponse = await TasksApi.PutTaskAsync(new PutTaskRequest
{
    TaskUid = 4,
    Task = task,
    FileName = remoteName,
    Name = remoteName,
    Folder = this.DataFolder,
    Mode = CalculationMode.None,
    Recalculate = false
});

Assert.AreEqual((int)HttpStatusCode.OK, putResponse.Code);

Examples-PutTaskLink.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");

var linksResponse = await TasksApi.GetTaskLinksAsync(new GetTaskLinksRequest()
{
    Name = remoteName,
    Folder = this.DataFolder
});

var taskLinkToEdit = linksResponse.TaskLinks[0];

// Modification of PredecessorUid and SuccessorUid fields is not supported.
taskLinkToEdit.LinkType = TaskLinkType.StartToFinish;
taskLinkToEdit.Lag = 9600;
taskLinkToEdit.LagFormat = TimeUnitType.Day;

var response = await TasksApi.PutTaskLinkAsync(new PutTaskLinkRequest()
{
    Index = 1,
    TaskLink = taskLinkToEdit,
    Name = remoteName,
    Folder = this.DataFolder
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-UpdateProjectByLoginPassword.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.UpdateProjectAsync(new UpdateProjectRequest()
{
    Name = remoteName,
    UserName = "SomeLogin",
    XSharepointPassword = "SomePassword",
    SiteUrl = "http://project_server_instance.local/sites/pwa"
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);

Examples-UpdateProjectByToken.cs

// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet/
var remoteName = await UploadFileToStorageAsync("NewProductDev.mpp");
var response = await TasksApi.UpdateProjectAsync(new UpdateProjectRequest()
{
    Name = remoteName,
    XProjectOnlineToken = "SOMESECRETTOKEN",
    SiteUrl = "http://project_server_instance.local/sites/pwa"
});

Assert.AreEqual((int)HttpStatusCode.OK, response.Code);