Get work week collection of calendar

Introduction

This example explains how to get the collection of work weeks of the specified calendar, using Aspose.Tasks Cloud. Aspose.Tasks Cloud is a REST API which can be used with any language: .NET, Java, PHP, Ruby, Rails, Python, jQuery and many more.

API Information

API	Type	Description	Resource Link
/tasks/{name}/calendars/{calendarUid}/workWeeks	GET	Read work week information for a give Calendar within a MS Project File	GetCalendarWorkWeeks

cURL Example

Request

curl -X GET "https://api.aspose.cloud/v3.0/tasks/Home%20move%20plan.mpp/calendars/1/workWeeks" -H "accept: application/json"

Response

{
  "code": 0,
  "status": "string",
  "calendarWorkWeeks": [
    {
      "name": "string",
      "fromDate": "2020-09-18T10:29:50.766Z",
      "toDate": "2020-09-18T10:29:50.766Z",
      "weekDays": [
        {
          "dayType": "Exception",
          "dayWorking": true,
          "fromDate": "2020-09-18T10:29:50.767Z",
          "toDate": "2020-09-18T10:29:50.767Z",
          "workingTimes": [
            {
              "fromTime": "2020-09-18T10:29:50.767Z",
              "toTime": "2020-09-18T10:29:50.767Z"
            }
          ]
        }
      ]
    }
  ]
}

SDKs

The Aspose.Tasks Cloud SDKs can be downloaded from the following page: Available SDKs

SDK Examples

	// 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);

view raw Examples-GetCalendarWorkWeeks.cs hosted with ❤ by GitHub

PHP

	<?
	// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-php/
	$remoteName = "GetCalendarWorkWeeks.mpp";
	$folder = $this->uploadFile("CalendarWorkWeeks.mpp", $remoteName, '');

	$response = $this->tasks->getCalendars(new Requests\GetCalendarsRequest($remoteName, self::$storageName, $folder));

	Assert::assertEquals(200, $response->getCode());
	Assert::assertNotNull($response->getCalendars());

	$calendarUid;
	foreach($response->getCalendars()->getList() as $calendar)
	{
	if($calendar->getName() == "Test work weeks")
	{
	$calendarUid = $calendar->getUid();
	break;
	}
	}

	$response = $this->tasks->getCalendarWorkWeeks(new Requests\GetCalendarWorkWeeksRequest($remoteName, $calendarUid, self::$storageName, $folder));
	Assert::assertEquals(200, $response->getCode());
	Assert::assertNotNull($response->getCalendarWorkWeeks());
	Assert::assertEquals(1, count($response->getCalendarWorkWeeks()));

	$workWeek = $response->getCalendarWorkWeeks()[0];

	Assert::assertEquals("Work week 1", $workWeek->getName());
	Assert::assertEquals("2018-01-01", $workWeek->getFromDate()->format("Y-m-d"));
	Assert::assertEquals("2018-01-07", $workWeek->getToDate()->format("Y-m-d"));

	Assert::assertEquals(4, count($workWeek->getWeekDays()));
	Assert::assertEquals(true, $workWeek->getWeekDays()[0]->getDayWorking());
	Assert::assertEquals(DayType::MONDAY, $workWeek->getWeekDays()[0]->getDayType());
	Assert::assertEquals(1, count($workWeek->getWeekDays()[0]->getWorkingTimes()));
	Assert::assertEquals("11:30:00", $workWeek->getWeekDays()[0]->getWorkingTimes()[0]->getFromTime()->format("H:i:s"));
	Assert::assertEquals("12:30:00", $workWeek->getWeekDays()[0]->getWorkingTimes()[0]->getToTime()->format("H:i:s"));

	Assert::assertEquals(false, $workWeek->getWeekDays()[1]->getDayWorking());
	Assert::assertEquals(DayType::TUESDAY, $workWeek->getWeekDays()[1]->getDayType());
	Assert::assertEquals(0, count($workWeek->getWeekDays()[1]->getWorkingTimes()));

	Assert::assertEquals(true, $workWeek->getWeekDays()[2]->getDayWorking());
	Assert::assertEquals(DayType::WEDNESDAY, $workWeek->getWeekDays()[2]->getDayType());
	Assert::assertEquals(2, count($workWeek->getWeekDays()[2]->getWorkingTimes()));

	Assert::assertEquals("09:30:00", $workWeek->getWeekDays()[2]->getWorkingTimes()[0]->getFromTime()->format("H:i:s"));
	Assert::assertEquals("13:23:00", $workWeek->getWeekDays()[2]->getWorkingTimes()[0]->getToTime()->format("H:i:s"));
	Assert::assertEquals("14:45:00", $workWeek->getWeekDays()[2]->getWorkingTimes()[1]->getFromTime()->format("H:i:s"));
	Assert::assertEquals("18:45:00", $workWeek->getWeekDays()[2]->getWorkingTimes()[1]->getToTime()->format("H:i:s"));

	Assert::assertEquals(true, $workWeek->getWeekDays()[3]->getDayWorking());
	Assert::assertEquals(DayType::SATURDAY, $workWeek->getWeekDays()[3]->getDayType());
	Assert::assertEquals(1, count($workWeek->getWeekDays()[3]->getWorkingTimes()));

	Assert::assertEquals("09:00:00", $workWeek->getWeekDays()[3]->getWorkingTimes()[0]->getFromTime()->format("H:i:s"));
	Assert::assertEquals("10:00:00", $workWeek->getWeekDays()[3]->getWorkingTimes()[0]->getToTime()->format("H:i:s"));

view raw Example-getCalendarWorkWeeks.php hosted with ❤ by GitHub

Python

	# For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-python
	filename = 'CalendarWorkWeeks.mpp'
	self.upload_file(filename)
	calendars_request = GetCalendarsRequest(filename)
	calendars_result = self.tasks_api.get_calendars(calendars_request)
	self.assertIsNotNone(calendars_result)
	self.assertIsInstance(calendars_result, CalendarItemsResponse)
	self.assertIsNotNone(calendars_result.calendars)
	calendar_uid = next(c for c in calendars_result.calendars.list if c.name == 'Test work weeks').uid
	work_weeks_result = self.tasks_api.get_calendar_work_weeks(GetCalendarWorkWeeksRequest(filename, calendar_uid))
	self.assertIsNotNone(work_weeks_result)
	self.assertIsInstance(work_weeks_result, CalendarWorkWeeksResponse)
	self.assertEqual(1, len(work_weeks_result.calendar_work_weeks))
	work_week = work_weeks_result.calendar_work_weeks[0]
	self.assertEqual('Work week 1', work_week.name)
	self.assertEqual("2018-01-01", work_week.from_date.strftime("%Y-%m-%d"))
	self.assertEqual("2018-01-07", work_week.to_date.strftime("%Y-%m-%d"))

	self.assertEqual(4, len(work_week.week_days))
	self.assertEqual(True, work_week.week_days[0].day_working)
	self.assertEqual(DayType.MONDAY, work_week.week_days[0].day_type)
	self.assertEqual(1, len(work_week.week_days[0].working_times))
	self.assertEqual("11:30:00", work_week.week_days[0].working_times[0].from_time.strftime("%H:%M:%S"))
	self.assertEqual("12:30:00", work_week.week_days[0].working_times[0].to_time.strftime("%H:%M:%S"))

	self.assertEqual(False, work_week.week_days[1].day_working)
	self.assertEqual(DayType.TUESDAY, work_week.week_days[1].day_type)
	self.assertEqual(0, len(work_week.week_days[1].working_times))

	self.assertEqual(True, work_week.week_days[2].day_working)
	self.assertEqual(DayType.WEDNESDAY, work_week.week_days[2].day_type)
	self.assertEqual(2, len(work_week.week_days[2].working_times))

	self.assertEqual("09:30:00", work_week.week_days[2].working_times[0].from_time.strftime("%H:%M:%S"))
	self.assertEqual("13:23:00", work_week.week_days[2].working_times[0].to_time.strftime("%H:%M:%S"))
	self.assertEqual("14:45:00", work_week.week_days[2].working_times[1].from_time.strftime("%H:%M:%S"))
	self.assertEqual("18:45:00", work_week.week_days[2].working_times[1].to_time.strftime("%H:%M:%S"))

	self.assertEqual(True, work_week.week_days[3].day_working)
	self.assertEqual(DayType.SATURDAY, work_week.week_days[3].day_type)
	self.assertEqual(1, len(work_week.week_days[3].working_times))

	self.assertEqual("09:00:00", work_week.week_days[3].working_times[0].from_time.strftime("%H:%M:%S"))
	self.assertEqual("10:00:00", work_week.week_days[3].working_times[0].to_time.strftime("%H:%M:%S"))

view raw get_calendar_work_weeks.py hosted with ❤ by GitHub

Node.js

	// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-node

	const fileName = "CalendarWorkWeeks.mpp";
	const localPath = "./Data/" + fileName;
	const remotePath = "Temp/Data";
	const remoteFullPath = remotePath + "/" + fileName;

	await tasksApi.uploadFileToStorage(remoteFullPath, localPath);

	const request = new GetCalendarsRequest();
	request.name = fileName;
	request.folder = remotePath;
	const result = await tasksApi.getCalendars(request);
	expect(result.response.statusCode).to.equal(200);
	expect(result.body.calendars.list).is.not.null.and.undefined;

	const calendarUid = result.body.calendars.list.find(c => c.name === "Test work weeks").uid;
	const request2 = new GetCalendarWorkWeeksRequest();
	request2.name = fileName;
	request2.folder = remotePath;
	request2.calendarUid = calendarUid;
	const result2 = await tasksApi.getCalendarWorkWeeks(request2);
	expect(result2.response.statusCode).to.equal(200);
	expect(result2.body.calendarWorkWeeks).is.not.null.and.undefined;
	expect(result2.body.calendarWorkWeeks.length).to.equal(1);
	const workWeek = result2.body.calendarWorkWeeks[0];
	expect(workWeek.name).to.equal("Work week 1");
	expect(BaseTest.getDateOnly(workWeek.fromDate)).to.eql(BaseTest.getDateOnly(new Date(2018, 0, 1)));
	expect(BaseTest.getDateOnly(workWeek.toDate)).to.eql(BaseTest.getDateOnly(new Date(2018, 0, 7, 8)));

	expect(workWeek.weekDays.length).to.equal(4);
	expect(workWeek.weekDays[0].dayWorking).is.true;
	expect(workWeek.weekDays[0].dayType).to.equal(DayType.Monday);
	expect(workWeek.weekDays[0].workingTimes.length).to.equal(1);
	expect(BaseTest.getTimeOnly(workWeek.weekDays[0].workingTimes[0].fromTime)).to.eql(new Date(Date.UTC(0, 0, 0, 11, 30, 0)));
	expect(BaseTest.getTimeOnly(workWeek.weekDays[0].workingTimes[0].toTime)).to.eql(new Date(Date.UTC(0, 0, 0, 12, 30, 0)));

	expect(workWeek.weekDays[1].dayWorking).is.false;
	expect(workWeek.weekDays[1].dayType).to.equal(DayType.Tuesday);
	expect(workWeek.weekDays[1].workingTimes.length).to.equal(0);

	expect(workWeek.weekDays[2].dayWorking).is.true;
	expect(workWeek.weekDays[2].dayType).to.equal(DayType.Wednesday);
	expect(workWeek.weekDays[2].workingTimes.length).to.equal(2);
	expect(BaseTest.getTimeOnly(workWeek.weekDays[2].workingTimes[0].fromTime)).to.eql(new Date(Date.UTC(0, 0, 0, 9, 30, 0)));
	expect(BaseTest.getTimeOnly(workWeek.weekDays[2].workingTimes[0].toTime)).to.eql(new Date(Date.UTC(0, 0, 0, 13, 23, 0)));
	expect(BaseTest.getTimeOnly(workWeek.weekDays[2].workingTimes[1].fromTime)).to.eql(new Date(Date.UTC(0, 0, 0, 14, 45, 0)));
	expect(BaseTest.getTimeOnly(workWeek.weekDays[2].workingTimes[1].toTime)).to.eql(new Date(Date.UTC(0, 0, 0, 18, 45, 0)));

	expect(workWeek.weekDays[3].dayWorking).is.true;
	expect(workWeek.weekDays[3].dayType).to.equal(DayType.Saturday);
	expect(workWeek.weekDays[3].workingTimes.length).to.equal(1);
	expect(BaseTest.getTimeOnly(workWeek.weekDays[3].workingTimes[0].fromTime)).to.eql(new Date(Date.UTC(0, 0, 0, 9, 0, 0)));
	expect(BaseTest.getTimeOnly(workWeek.weekDays[3].workingTimes[0].toTime)).to.eql(new Date(Date.UTC(0, 0, 0, 10, 0, 0)));

view raw getCalendarWorkWeeks.ts hosted with ❤ by GitHub

	// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-go/
	client, ctx := UploadTestFileToStorage(t, localFileName, remoteBaseTestDataFolder+"/"+remoteFileName)

	getCalendarsResult, _, err := client.TasksApi.GetCalendars(ctx, &requests.GetCalendarsOpts{
	Name: remoteFileName,
	Folder: optional.NewString(remoteBaseTestDataFolder),
	})
	if err != nil {
	t.Error(err)
	}

	var calendarUid int32
	for _, calendar := range getCalendarsResult.Calendars.List {
	if calendar.Name == "Test work weeks" {
	calendarUid = calendar.Uid
	break
	}
	}

	getCalendarWorkWeeksResult, _, err := client.TasksApi.GetCalendarWorkWeeks(ctx, &requests.GetCalendarWorkWeeksOpts{
	Name: remoteFileName,
	Folder: optional.NewString(remoteBaseTestDataFolder),
	CalendarUid: calendarUid,
	})
	if err != nil {
	t.Error(err)
	}
	assert.Equal(t, int32(200), getCalendarWorkWeeksResult.Code)
	assert.Equal(t, 1, len(getCalendarWorkWeeksResult.CalendarWorkWeeks))
	workWeek := getCalendarWorkWeeksResult.CalendarWorkWeeks[0]
	assert.Equal(t, "Work week 1", workWeek.Name)
	assert.Equal(t, "2018-01-01", ExtractDateOnly(workWeek.FromDate))
	assert.Equal(t, "2018-01-07", ExtractDateOnly(workWeek.ToDate))
	assert.Equal(t, 4, len(workWeek.WeekDays))
	assert.True(t, workWeek.WeekDays[0].DayWorking)
	assert.Equal(t, models.MONDAY_DayType, *workWeek.WeekDays[0].DayType)
	assert.Equal(t, 1, len(workWeek.WeekDays[0].WorkingTimes))
	assert.Equal(t, "11:30:00", ExtractTimeOnly(workWeek.WeekDays[0].WorkingTimes[0].FromTime))
	assert.Equal(t, "12:30:00", ExtractTimeOnly(workWeek.WeekDays[0].WorkingTimes[0].ToTime))

	assert.False(t, workWeek.WeekDays[1].DayWorking)
	assert.Equal(t, models.TUESDAY_DayType, *workWeek.WeekDays[1].DayType)
	assert.Equal(t, 0, len(workWeek.WeekDays[1].WorkingTimes))

	assert.True(t, workWeek.WeekDays[2].DayWorking)
	assert.Equal(t, models.WEDNESDAY_DayType, *workWeek.WeekDays[2].DayType)
	assert.Equal(t, 2, len(workWeek.WeekDays[2].WorkingTimes))
	assert.Equal(t, "09:30:00", ExtractTimeOnly(workWeek.WeekDays[2].WorkingTimes[0].FromTime))
	assert.Equal(t, "13:23:00", ExtractTimeOnly(workWeek.WeekDays[2].WorkingTimes[0].ToTime))
	assert.Equal(t, "14:45:00", ExtractTimeOnly(workWeek.WeekDays[2].WorkingTimes[1].FromTime))
	assert.Equal(t, "18:45:00", ExtractTimeOnly(workWeek.WeekDays[2].WorkingTimes[1].ToTime))

	assert.True(t, workWeek.WeekDays[0].DayWorking)
	assert.Equal(t, models.SATURDAY_DayType, *workWeek.WeekDays[3].DayType)
	assert.Equal(t, 1, len(workWeek.WeekDays[3].WorkingTimes))
	assert.Equal(t, "09:00:00", ExtractTimeOnly(workWeek.WeekDays[3].WorkingTimes[0].FromTime))
	assert.Equal(t, "10:00:00", ExtractTimeOnly(workWeek.WeekDays[3].WorkingTimes[0].ToTime))

view raw Examples-GetCalendarWorkWeeks.go hosted with ❤ by GitHub

Java

	// For complete examples and data files, please go to https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-java/
	String localFileName = "CalendarWorkWeeks.mpp";
	String remoteFileName = TestInitializer.UploadFile(localFileName);
	GetCalendarsRequest request1 = new GetCalendarsRequest(remoteFileName, null, null);
	CalendarItemsResponse result1 = TestInitializer.tasksApi.getCalendars(request1);
	assertNotNull(result1);
	assertNotNull(result1.getCalendars());
	Integer calendarUid = result1.getCalendars().getList().stream().filter(c -> c.getName().equals("Test work weeks")).findAny().get().getUid();
	GetCalendarWorkWeeksRequest request2 = new GetCalendarWorkWeeksRequest(remoteFileName, calendarUid,null, null);
	CalendarWorkWeeksResponse result2 = TestInitializer.tasksApi.getCalendarWorkWeeks(request2);
	assertEquals(200, (int) result2.getCode());
	assertNotNull(result2.getCalendarWorkWeeks());
	assertEquals(1, result2.getCalendarWorkWeeks().size());
	WorkWeek workWeek = result2.getCalendarWorkWeeks().get(0);
	assertEquals("Work week 1", workWeek.getName());
	assertEquals(OffsetDateTime.of(2018, 1, 1, 0, 0, 0, 0, ZoneOffset.UTC), workWeek.getFromDate());
	assertEquals(OffsetDateTime.of(2018, 1, 7, 23, 59, 0, 0, ZoneOffset.UTC), workWeek.getToDate());
	assertEquals(4, workWeek.getWeekDays().size());
	assertTrue(workWeek.getWeekDays().get(0).isDayWorking());
	assertEquals(DayType.MONDAY, workWeek.getWeekDays().get(0).getDayType());
	assertEquals(1, workWeek.getWeekDays().get(0).getWorkingTimes().size());
	assertEquals(OffsetDateTime.of(1, 1, 1, 11, 30, 0, 0, ZoneOffset.UTC), workWeek.getWeekDays().get(0).getWorkingTimes().get(0).getFromTime());
	assertEquals(OffsetDateTime.of(1, 1, 1, 12, 30, 0, 0, ZoneOffset.UTC), workWeek.getWeekDays().get(0).getWorkingTimes().get(0).getToTime());
	assertFalse(workWeek.getWeekDays().get(1).isDayWorking());
	assertEquals(DayType.TUESDAY, workWeek.getWeekDays().get(1).getDayType());
	assertEquals(0, workWeek.getWeekDays().get(1).getWorkingTimes().size());
	assertTrue(workWeek.getWeekDays().get(2).isDayWorking());
	assertEquals(DayType.WEDNESDAY, workWeek.getWeekDays().get(2).getDayType());
	assertEquals(2, workWeek.getWeekDays().get(2).getWorkingTimes().size());
	assertEquals(OffsetDateTime.of(1, 1, 1, 9, 30, 0, 0, ZoneOffset.UTC), workWeek.getWeekDays().get(2).getWorkingTimes().get(0).getFromTime());
	assertEquals(OffsetDateTime.of(1, 1, 1, 13, 23, 0, 0, ZoneOffset.UTC), workWeek.getWeekDays().get(2).getWorkingTimes().get(0).getToTime());
	assertEquals(OffsetDateTime.of(1, 1, 1, 14, 45, 0, 0, ZoneOffset.UTC), workWeek.getWeekDays().get(2).getWorkingTimes().get(1).getFromTime());
	assertEquals(OffsetDateTime.of(1, 1, 1, 18, 45, 0, 0, ZoneOffset.UTC), workWeek.getWeekDays().get(2).getWorkingTimes().get(1).getToTime());
	assertTrue(workWeek.getWeekDays().get(3).isDayWorking());
	assertEquals(DayType.SATURDAY, workWeek.getWeekDays().get(3).getDayType());
	assertEquals(1, workWeek.getWeekDays().get(3).getWorkingTimes().size());
	assertEquals(OffsetDateTime.of(1, 1, 1, 9, 0, 0, 0, ZoneOffset.UTC), workWeek.getWeekDays().get(3).getWorkingTimes().get(0).getFromTime());
	assertEquals(OffsetDateTime.of(1, 1, 1, 10, 0, 0, 0, ZoneOffset.UTC), workWeek.getWeekDays().get(3).getWorkingTimes().get(0).getToTime());

view raw Examples-GetCalendarWorkWeeks.java hosted with ❤ by GitHub

Get Specific Calendar of a Project Add Calendar to Project