Get Calendar Exceptions

Introduction

This example allows you to read information about calendar exceptions, 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}/calendarExceptions	GET	Read Calendar Exception Information	GetCalendarExceptions

cURL Example

Request


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

Response


{
  "code": 0,
  "status": "string",
  "calendarExceptions": [
    {
      "index": 0,
      "enteredByOccurrences": true,
      "fromDate": "2020-09-19T09:47:07.348Z",
      "toDate": "2020-09-19T09:47:07.348Z",
      "occurrences": 0,
      "name": "string",
      "type": "Daily",
      "period": 0,
      "daysOfWeek": [
        "Exception"
      ],
      "monthItem": "Day",
      "monthPosition": "First",
      "month": "January",
      "monthDay": 0,
      "dayWorking": true,
      "workingTimes": [
        {
          "fromTime": "2020-09-19T09:47:07.348Z",
          "toTime": "2020-09-19T09:47:07.348Z"
        }
      ]
    }
  ]
}

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("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);

view raw Examples-GetCalendarExceptions.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 = "GetCalendarExceptions.mpp";
	$folder = $this->uploadFile("Calenar with exception.mpp", $remoteName, '');

	$response = $this->tasks->getCalendarExceptions(new Requests\GetCalendarExceptionsRequest($remoteName, 1, self::$storageName, $folder));

	Assert::assertEquals(200, $response->getCode());
	Assert::assertNotNull($response->getCalendarExceptions());
	Assert::assertEquals(1, count($response->getCalendarExceptions()));
	$calendarException = $response->getCalendarExceptions()[0];

	Assert::assertEquals(true, $calendarException->getDayWorking());
	Assert::assertEquals(1, count($calendarException->getDaysOfWeek()));
	Assert::assertEquals(DayType::MONDAY, $calendarException->getDaysOfWeek()[0]);
	Assert::assertEquals("2018-02-13", $calendarException->getFromDate()->format("Y-m-d"));
	Assert::assertEquals("2018-04-09", $calendarException->getToDate()->format("Y-m-d"));

	Assert::assertEquals(Month::UNDEFINED, $calendarException->getMonth());
	Assert::assertEquals(MonthItemType::UNDEFINED, $calendarException->getMonthItem());
	Assert::assertEquals(MonthPosition::UNDEFINED, $calendarException->getMonthPosition());
	Assert::assertEquals(CalendarExceptionType::WEEKLY, $calendarException->getType());
	Assert::assertEquals(8, $calendarException->getOccurrences());
	Assert::assertEquals(1, $calendarException->getPeriod());
	Assert::assertEquals(2, count($calendarException->getWorkingTimes()));
	Assert::assertEquals("09:00:00", $calendarException->getWorkingTimes()[0]->getFromTime()->format("H:i:s"));
	Assert::assertEquals("12:34:00", $calendarException->getWorkingTimes()[0]->getToTime()->format("H:i:s"));
	Assert::assertEquals("15:11:00", $calendarException->getWorkingTimes()[1]->getFromTime()->format("H:i:s"));
	Assert::assertEquals("17:30:00", $calendarException->getWorkingTimes()[1]->getToTime()->format("H:i:s"));

view raw Example-getCalendarExceptions.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 = 'Calenar_with_exception.mpp'
	self.upload_file(filename)
	request = GetCalendarExceptionsRequest(filename, 1)
	result = self.tasks_api.get_calendar_exceptions(request)
	self.assertIsNotNone(result)
	self.assertIsInstance(result, CalendarExceptionsResponse)
	self.assertIsNotNone(result.calendar_exceptions)
	self.assertEqual(1, len(result.calendar_exceptions))

	calendar_exception = result.calendar_exceptions[0]
	self.assertTrue(calendar_exception.day_working)
	self.assertEqual([DayType.MONDAY], calendar_exception.days_of_week)
	self.assertEqual("2018-02-13", calendar_exception.from_date.strftime("%Y-%m-%d"))
	self.assertEqual("2018-04-09", calendar_exception.to_date.strftime("%Y-%m-%d"))
	self.assertEqual(Month.UNDEFINED, calendar_exception.month)
	self.assertEqual(MonthItemType.UNDEFINED, calendar_exception.month_item)
	self.assertEqual(MonthPosition.UNDEFINED, calendar_exception.month_position)
	self.assertEqual(CalendarExceptionType.WEEKLY, calendar_exception.type)
	self.assertEqual(8, calendar_exception.occurrences)
	self.assertEqual(1, calendar_exception.period)
	self.assertEqual(2, len(calendar_exception.working_times))
	self.assertEqual("09:00:00", calendar_exception.working_times[0].from_time.strftime("%H:%M:%S"))
	self.assertEqual("12:34:00", calendar_exception.working_times[0].to_time.strftime("%H:%M:%S"))
	self.assertEqual("15:11:00", calendar_exception.working_times[1].from_time.strftime("%H:%M:%S"))
	self.assertEqual("17:30:00", calendar_exception.working_times[1].to_time.strftime("%H:%M:%S"))

view raw get_calendar_exceptions.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 = "Calenar_with_exception.mpp";
	const localPath = "./Data/" + fileName;
	const remotePath = "Temp/Data";
	const remoteFullPath = remotePath + "/" + fileName;

	await tasksApi.uploadFileToStorage(remoteFullPath, localPath);

	const request = new GetCalendarExceptionsRequest();
	request.name = fileName;
	request.folder = remotePath;
	request.calendarUid = 1;

	const result = await tasksApi.getCalendarExceptions(request);
	expect(result.response.statusCode).to.equal(200);
	expect(result.body.calendarExceptions).is.not.undefined.and.not.null ;
	expect(result.body.calendarExceptions.length).to.equal(1);

	const calendarException = result.body.calendarExceptions[0];
	expect(calendarException.dayWorking).is.true;
	expect(calendarException.daysOfWeek).to.eql( [DayType.Monday]);
	expect(calendarException.fromDate).to.eql(new Date(2018, 1, 13));
	expect(calendarException.toDate).to.eql(new Date(2018, 3, 9, 23, 59));
	expect(calendarException.month).to.eql(Month.Undefined);
	expect(calendarException.monthItem).to.eql(MonthItemType.Undefined);
	expect(calendarException.monthPosition).to.eql(MonthPosition.Undefined);
	expect(calendarException.type).to.eql(CalendarExceptionType.Weekly);
	expect(calendarException.occurrences).to.eql(8);
	expect(calendarException.period).to.eql(1);
	expect(calendarException.workingTimes.length).to.eql(2);
	expect(BaseTest.getTimeOnly(calendarException.workingTimes[0].fromTime)).to.eql(new Date(0, 0, 0, 13, 2, 33));
	expect(BaseTest.getTimeOnly(calendarException.workingTimes[0].toTime)).to.eql(new Date(0, 0, 0, 16, 36, 33));
	expect(BaseTest.getTimeOnly(calendarException.workingTimes[1].fromTime)).to.eql(new Date(0, 0, 0, 19, 13, 33));
	expect(BaseTest.getTimeOnly(calendarException.workingTimes[1].toTime)).to.eql(new Date(0, 0, 0, 21, 32, 33));

view raw getCalendarExceptions.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)

	options := &requests.GetCalendarExceptionsOpts{
	CalendarUid: 1,
	Name: remoteFileName,
	Folder: optional.NewString(remoteBaseTestDataFolder),
	}
	result, _, err := client.TasksApi.GetCalendarExceptions(ctx, options)

	if err != nil {
	t.Error(err)
	}
	assert.Equal(t, int32(200), result.Code)
	assert.NotNil(t, result.CalendarExceptions)
	assert.Equal(t, 1, len(result.CalendarExceptions))
	calendarException := result.CalendarExceptions[0]
	assert.True(t, calendarException.DayWorking)
	assert.Equal(t, []models.DayType{models.MONDAY_DayType}, calendarException.DaysOfWeek)
	assert.Equal(t, CreateTime(2018, 2, 13, 0, 0, 0), calendarException.FromDate)
	assert.Equal(t, CreateTime(2018, 4, 9, 23, 59, 0), calendarException.ToDate)
	assert.Equal(t, models.UNDEFINED_Month, *calendarException.Month)
	assert.Equal(t, models.UNDEFINED_MonthItemType, *calendarException.MonthItem)
	assert.Equal(t, models.UNDEFINED_MonthPosition, *calendarException.MonthPosition)
	assert.Equal(t, models.WEEKLY_CalendarExceptionType, *calendarException.Type_)
	assert.Equal(t, int32(8), calendarException.Occurrences)
	assert.Equal(t, int32(1), calendarException.Period)
	assert.Equal(t, 2, len(calendarException.WorkingTimes))
	assert.Equal(t, "09:00:00", ExtractTimeOnly(calendarException.WorkingTimes[0].FromTime))
	assert.Equal(t, "12:34:00", ExtractTimeOnly(calendarException.WorkingTimes[0].ToTime))
	assert.Equal(t, "15:11:00", ExtractTimeOnly(calendarException.WorkingTimes[1].FromTime))
	assert.Equal(t, "17:30:00", ExtractTimeOnly(calendarException.WorkingTimes[1].ToTime))

view raw Examples-GetCalendarExceptions.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 = "Calenar_with_exception.mpp";
	String remoteFileName = TestInitializer.UploadFile(localFileName);

	GetCalendarExceptionsRequest request = new GetCalendarExceptionsRequest(remoteFileName, 1, null, null);
	CalendarExceptionsResponse result = TestInitializer.tasksApi.getCalendarExceptions(request);
	assertNotNull(result);
	assertEquals(200, (int) result.getCode());
	assertNotNull(result.getCalendarExceptions());
	assertEquals(1, result.getCalendarExceptions().size());
	CalendarException calendarException = result.getCalendarExceptions().get(0);
	assertTrue(calendarException.isDayWorking());
	assertEquals(Arrays.asList(DayType.MONDAY), calendarException.getDaysOfWeek());
	assertEquals(OffsetDateTime.of(2018, 2, 13, 0, 0, 0, 0, ZoneOffset.UTC), calendarException.getFromDate());
	assertEquals(OffsetDateTime.of(2018, 4, 9, 23, 59, 0, 0, ZoneOffset.UTC), calendarException.getToDate());
	assertEquals(Month.UNDEFINED, calendarException.getMonth());
	assertEquals(MonthItemType.UNDEFINED, calendarException.getMonthItem());
	assertEquals(MonthPosition.UNDEFINED, calendarException.getMonthPosition());
	assertEquals(CalendarExceptionType.WEEKLY, calendarException.getType());
	assertEquals(Integer.valueOf(8), calendarException.getOccurrences());
	assertEquals(Integer.valueOf(1), calendarException.getPeriod());
	assertEquals(2, calendarException.getWorkingTimes().size());
	assertEquals(OffsetDateTime.of(1, 1, 1, 9, 0, 0, 0, ZoneOffset.UTC), calendarException.getWorkingTimes().get(0).getFromTime());
	assertEquals(OffsetDateTime.of(1, 1, 1, 12, 34, 0, 0, ZoneOffset.UTC), calendarException.getWorkingTimes().get(0).getToTime());
	assertEquals(OffsetDateTime.of(1, 1, 1, 15, 11, 0, 0, ZoneOffset.UTC), calendarException.getWorkingTimes().get(1).getFromTime());
	assertEquals(OffsetDateTime.of(1, 1, 1, 17, 30, 0, 0, ZoneOffset.UTC), calendarException.getWorkingTimes().get(1).getToTime());

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

Add Calendar Exception