public void CanPerformAvailabilityWithBuffersAndIntervalQuery()
        {
            const string requestBody = @"
                {
                  ""participants"": [
                    {
                      ""members"": [
                        { ""sub"": ""acc_567236000909002"" },
                        { ""sub"": ""acc_678347111010113"" }
                      ],
                      ""required"": ""all""
                    }
                  ],
                  ""required_duration"": { ""minutes"": 60 },
                  ""available_periods"": [
                    {
                      ""start"": ""2017-01-03 09:00:00Z"",
                      ""end"": ""2017-01-03 18:00:00Z""
                    }
                  ],
                  ""start_interval"":{ ""minutes"": 60 },
                  ""buffer"":{
                    ""before"":{
                      ""minimum"":{ ""minutes"": 30 } 
                    },
                    ""after"":{
                      ""minimum"":{ ""minutes"": 60 } 
                    }
                  }
                }";

            var builder = new AvailabilityRequestBuilder()
                          .RequiredDuration(60)
                          .StartInterval(60)
                          .BeforeBuffer(30)
                          .AfterBuffer(60)
                          .AddAvailablePeriod(
                new DateTimeOffset(2017, 1, 3, 9, 0, 0, TimeSpan.Zero),
                new DateTimeOffset(2017, 1, 3, 18, 0, 0, TimeSpan.Zero))
                          .AddRequiredParticipant("acc_567236000909002")
                          .AddRequiredParticipant("acc_678347111010113");

            const string responseBody = @"
                {
                  ""available_periods"": [ ]
                }";

            Http.Stub(
                HttpPost
                .Url("https://api.cronofy.com/v1/availability")
                .RequestHeader("Authorization", "Bearer " + AccessToken)
                .JsonRequest(requestBody)
                .ResponseCode(200)
                .ResponseBody(responseBody)
                );

            var availability = Client.GetAvailability(builder);

            Assert.IsEmpty(availability);
        }
Beispiel #2
0
        /// <summary>
        /// Real-Time Scheduling example.
        /// </summary>
        private static void RealTimeSchedulingExample()
        {
            Console.Write("Enter Client id: ");
            var clientId = Console.ReadLine();

            Console.Write("Enter Secret: ");
            var clientSecret = Console.ReadLine();

            Console.Write("Enter Account id for availablity: ");
            var sub = Console.ReadLine();

            Console.Write("Enter calendar id for availablity: ");
            var calendarId = Console.ReadLine();

            string redirectUrl = "http://example.com/redirectUri";
            string scope       = "read_events create_event";

            string         eventId = "testEventId";
            string         summary = "Test Summary";
            DateTimeOffset start   = DateTime.Now;
            DateTimeOffset end     = DateTime.Now + new TimeSpan(2, 0, 0);

            var client = new CronofyOAuthClient(clientId, clientSecret);

            var upsertEventRequest = new UpsertEventRequestBuilder()
                                     .EventId(eventId)
                                     .Summary(summary)
                                     .Build();

            var availabilityRequest = new AvailabilityRequestBuilder()
                                      .AddParticipantGroup(new ParticipantGroupBuilder().AddMember(sub).AllRequired())
                                      .AddAvailablePeriod(start, end)
                                      .RequiredDuration(60)
                                      .Build();

            var request = new RealTimeSchedulingRequestBuilder()
                          .OAuthDetails(redirectUrl, scope)
                          .Timezone("Etc/UTC")
                          .UpsertEventRequest(upsertEventRequest)
                          .AvailabilityRequest(availabilityRequest)
                          .AddTargetCalendar(sub, calendarId)
                          .Build();

            var actualUrl = client.RealTimeScheduling(request);

            Console.WriteLine(actualUrl);

            Process.Start(actualUrl);
        }
        public static IEnumerable <Cronofy.AvailablePeriod> Availability(Models.Availability availability)
        {
            IEnumerable <Cronofy.AvailablePeriod> availablePeriods = null;

            var participants = new ParticipantGroupBuilder()
                               .AddMember(availability.AccountId1);

            if (availability.AccountId2 != null)
            {
                participants.AddMember(availability.AccountId2);
            }

            if (availability.RequiredParticipants == "All")
            {
                participants.AllRequired();
            }

            var builtAvailabilityRequest = new AvailabilityRequestBuilder()
                                           .AddParticipantGroup(participants)
                                           .RequiredDuration(availability.Duration)
                                           .AddAvailablePeriod(availability.Start, availability.End)
                                           .Build();

            try
            {
                availablePeriods = CronofyAccountRequest <IEnumerable <Cronofy.AvailablePeriod> >(() => { return(AccountClient.GetAvailability(builtAvailabilityRequest)); });
                LogHelper.Log("Availability success - accountId1=`{availability.AccountId1}` - accountId2=`{availability.AccountId2}` - requiredParticipants=`{availability.RequiredParticipants}` - duration=`{availability.Duration}` - start=`{availability.Start}` - end=`{availability.End}` - periods=`{JsonConvert.SerializeObject(availablePeriods)}`");
            }
            catch (CronofyException)
            {
                LogHelper.Log("Availability failure - accountId1=`{availability.AccountId1}` - accountId2=`{availability.AccountId2}` - requiredParticipants=`{availability.RequiredParticipants}` - duration=`{availability.Duration}` - start=`{availability.Start}` - end=`{availability.End}`");
                throw;
            }

            return(availablePeriods);
        }
        public void CanPerformAvailabilityQuery()
        {
            const string requestBody = @"
                {
                  ""participants"": [
                    {
                      ""members"": [
                        { ""sub"": ""acc_567236000909002"" },
                        { ""sub"": ""acc_678347111010113"" }
                      ],
                      ""required"": ""all""
                    }
                  ],
                  ""required_duration"": { ""minutes"": 60 },
                  ""available_periods"": [
                    {
                      ""start"": ""2017-01-03 09:00:00Z"",
                      ""end"": ""2017-01-03 18:00:00Z""
                    },
                    {
                      ""start"": ""2017-01-04 09:00:00Z"",
                      ""end"": ""2017-01-04 18:00:00Z""
                    }
                  ]
                }";

            var builder = new AvailabilityRequestBuilder()
                          .RequiredDuration(60)
                          .AddAvailablePeriod(
                new DateTimeOffset(2017, 1, 3, 9, 0, 0, TimeSpan.Zero),
                new DateTimeOffset(2017, 1, 3, 18, 0, 0, TimeSpan.Zero))
                          .AddAvailablePeriod(
                new DateTimeOffset(2017, 1, 4, 9, 0, 0, TimeSpan.Zero),
                new DateTimeOffset(2017, 1, 4, 18, 0, 0, TimeSpan.Zero))
                          .AddRequiredParticipant("acc_567236000909002")
                          .AddRequiredParticipant("acc_678347111010113");

            const string responseBody = @"
                {
                  ""available_periods"": [
                    {
                      ""start"": ""2017-01-03T09:00:00Z"",
                      ""end"": ""2017-01-03T11:00:00Z"",
                      ""participants"": [
                        { ""sub"": ""acc_567236000909002"" },
                        { ""sub"": ""acc_678347111010113"" }
                      ]
                    },
                    {
                      ""start"": ""2017-01-03T14:00:00Z"",
                      ""end"": ""2017-01-03T16:00:00Z"",
                      ""participants"": [
                        { ""sub"": ""acc_567236000909002"" },
                        { ""sub"": ""acc_678347111010113"" }
                      ]
                    },
                    {
                      ""start"": ""2017-01-04T11:00:00Z"",
                      ""end"": ""2017-01-04T17:00:00Z"",
                      ""participants"": [
                        { ""sub"": ""acc_567236000909002"" },
                        { ""sub"": ""acc_678347111010113"" }
                      ]
                    },
                  ]
                }";

            Http.Stub(
                HttpPost
                .Url("https://api.cronofy.com/v1/availability")
                .RequestHeader("Authorization", "Bearer " + AccessToken)
                .JsonRequest(requestBody)
                .ResponseCode(200)
                .ResponseBody(responseBody)
                );

            var availability = Client.GetAvailability(builder);

            var expected = new[]
            {
                new AvailablePeriod
                {
                    Start        = new DateTimeOffset(2017, 1, 3, 9, 0, 0, TimeSpan.Zero),
                    End          = new DateTimeOffset(2017, 1, 3, 11, 0, 0, TimeSpan.Zero),
                    Participants = new[]
                    {
                        new AvailablePeriod.Participant {
                            Sub = "acc_567236000909002"
                        },
                        new AvailablePeriod.Participant {
                            Sub = "acc_678347111010113"
                        },
                    },
                },
                new AvailablePeriod
                {
                    Start        = new DateTimeOffset(2017, 1, 3, 14, 0, 0, TimeSpan.Zero),
                    End          = new DateTimeOffset(2017, 1, 3, 16, 0, 0, TimeSpan.Zero),
                    Participants = new[]
                    {
                        new AvailablePeriod.Participant {
                            Sub = "acc_567236000909002"
                        },
                        new AvailablePeriod.Participant {
                            Sub = "acc_678347111010113"
                        },
                    },
                },
                new AvailablePeriod
                {
                    Start        = new DateTimeOffset(2017, 1, 4, 11, 0, 0, TimeSpan.Zero),
                    End          = new DateTimeOffset(2017, 1, 4, 17, 0, 0, TimeSpan.Zero),
                    Participants = new[]
                    {
                        new AvailablePeriod.Participant {
                            Sub = "acc_567236000909002"
                        },
                        new AvailablePeriod.Participant {
                            Sub = "acc_678347111010113"
                        },
                    },
                },
            };

            Assert.AreEqual(expected, availability);
        }
        public void CanPerformComplexAvailabilityQuery()
        {
            const string requestBody = @"
                {
                  ""participants"": [
                    {
                      ""members"": [
                        { ""sub"": ""acc_567236000909002"" },
                        {
                          ""sub"": ""acc_678347111010113"",
                          ""available_periods"": [
                            {
                              ""start"": ""2017-01-03 09:00:00Z"",
                              ""end"": ""2017-01-03 12:00:00Z""
                            }
                          ],
                          ""calendar_ids"": [
                            ""cal_1234_5678"",
                            ""cal_9876_5432""
                          ]
                        }
                      ],
                      ""required"": ""all""
                    },
                    {
                      ""members"": [
                        { ""sub"": ""acc_678910200909001"" },
                        { ""sub"": ""acc_879082061010114"" }
                      ],
                      ""required"": 1
                    }
                  ],
                  ""required_duration"": { ""minutes"": 60 },
                  ""available_periods"": [
                    {
                      ""start"": ""2017-01-03 09:00:00Z"",
                      ""end"": ""2017-01-03 18:00:00Z""
                    }
                  ]
                }";

            var member = new AvailabilityMemberBuilder()
                         .Sub("acc_678347111010113")
                         .AddAvailablePeriod(
                new DateTimeOffset(2017, 1, 3, 9, 0, 0, TimeSpan.Zero),
                new DateTimeOffset(2017, 1, 3, 12, 0, 0, TimeSpan.Zero))
                         .CalendarIds(new[] { "cal_1234_5678", "cal_9876_5432" });

            var requiredGroup = new ParticipantGroupBuilder()
                                .AddMember("acc_567236000909002")
                                .AddMember(member)
                                .AllRequired();

            var representedGroup = new ParticipantGroupBuilder()
                                   .AddMember("acc_678910200909001")
                                   .AddMember("acc_879082061010114")
                                   .Required(1);

            var builder = new AvailabilityRequestBuilder()
                          .RequiredDuration(60)
                          .AddAvailablePeriod(
                new DateTimeOffset(2017, 1, 3, 9, 0, 0, TimeSpan.Zero),
                new DateTimeOffset(2017, 1, 3, 18, 0, 0, TimeSpan.Zero))
                          .AddParticipantGroup(requiredGroup)
                          .AddParticipantGroup(representedGroup);

            const string responseBody = @"
                {
                  ""available_periods"": [
                    {
                      ""start"": ""2017-01-03T09:00:00Z"",
                      ""end"": ""2017-01-03T11:00:00Z"",
                      ""participants"": [
                        { ""sub"": ""acc_567236000909002"" },
                        { ""sub"": ""acc_678347111010113"" },
                        { ""sub"": ""acc_6789010200909001"" }
                      ]
                    }
                  ]
                }";

            Http.Stub(
                HttpPost
                .Url("https://api.cronofy.com/v1/availability")
                .RequestHeader("Authorization", "Bearer " + AccessToken)
                .JsonRequest(requestBody)
                .ResponseCode(200)
                .ResponseBody(responseBody)
                );

            var availability = Client.GetAvailability(builder);

            var expected = new[]
            {
                new AvailablePeriod
                {
                    Start        = new DateTimeOffset(2017, 1, 3, 9, 0, 0, TimeSpan.Zero),
                    End          = new DateTimeOffset(2017, 1, 3, 11, 0, 0, TimeSpan.Zero),
                    Participants = new[]
                    {
                        new AvailablePeriod.Participant {
                            Sub = "acc_567236000909002"
                        },
                        new AvailablePeriod.Participant {
                            Sub = "acc_678347111010113"
                        },
                        new AvailablePeriod.Participant {
                            Sub = "acc_6789010200909001"
                        },
                    },
                },
            };

            Assert.AreEqual(expected, availability);
        }