override public void Execute()
        {
            DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("ReminderExample: " + DateTime.Now)
                                                .WithSigner(SignerBuilder.NewSignerWithEmail(email1)
                                                            .WithFirstName("Patty")
                                                            .WithLastName("Galant"))
                                                .WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
                                                              .FromStream(fileStream1, DocumentType.PDF)
                                                              .WithSignature(SignatureBuilder.SignatureFor(email1)
                                                                             .OnPage(0)
                                                                             .AtPosition(100, 100)))
                                                .Build();

            packageId = eslClient.CreatePackage(superDuperPackage);

            eslClient.ReminderService.SetReminderScheduleForPackage(
                ReminderScheduleBuilder.ForPackageWithId(packageId)
                .WithDaysUntilFirstReminder(2)
                .WithDaysBetweenReminders(1)
                .WithNumberOfRepetitions(5)
                .Build()
                );

            reminderSchedule = eslClient.ReminderService.GetReminderScheduleForPackage(packageId);

            eslClient.SendPackage(packageId);

            eslClient.ReminderService.ClearReminderScheduleForPackage(packageId);
        }
Beispiel #2
0
        public async Task PutShouldReturnNotFound()
        {
            string userId = "Jack";
            var    user   = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
            {
                new Claim("userId", userId)
            }, "mock"));
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 102, Schedule = DateTime.Now.AddDays(2)
            };
            var mockService = new Mock <IReminderService>();

            mockService.Setup(svc => svc.UpdateReminder(userId, reminder)).Throws(new NoReminderFoundException("No reminder found for this news"));
            var controller = new ReminderController(mockService.Object);

            controller.ControllerContext = new ControllerContext {
                HttpContext = new DefaultHttpContext {
                    User = user
                }
            };

            var actual = await controller.Put(reminder);

            var actionResult = Assert.IsType <NotFoundObjectResult>(actual);

            Assert.Equal("No reminder found for this news", actionResult.Value);
        }
Beispiel #3
0
        private Proto.ReminderSchedule ScheduleToProto(Reminder.Schedule schedule)
        {
            var proto = new ReminderSchedule
            {
                TaskId      = schedule.TaskId,
                Recipient   = ActorPathToProto(schedule.Recipient),
                Payload     = MessageToProto(schedule.Message),
                TriggerDate = schedule.TriggerDateUtc.Ticks
            };

            switch (schedule)
            {
            case Reminder.ScheduleRepeatedly repeat:
                proto.RepeatInterval = repeat.RepeatInterval.Ticks;
                break;

            case Reminder.ScheduleCron cron:
                proto.CronExpression = cron.CronExpression.ToString();
                break;
            }

            if (schedule.Ack != null)
            {
                proto.Ack = MessageToProto(schedule.Ack);
            }

            return(proto);
        }
        public ReminderSchedule SetReminderScheduleForPackage(ReminderSchedule reminderSchedule)
        {
            PackageReminderSchedule apiPayload  = new ReminderScheduleConverter(reminderSchedule).ToAPIPackageReminderSchedule();
            PackageReminderSchedule apiResponse = apiClient.SetReminderScheduleForPackage(apiPayload);

            return(new ReminderScheduleConverter(apiResponse).ToSDKReminderSchedule());
        }
Beispiel #5
0
        public async Task PutShouldReturnOk()
        {
            string userId = "Jack";
            var    user   = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
            {
                new Claim("userId", userId)
            }, "mock"));
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 101, Schedule = DateTime.Now.AddDays(2)
            };
            var mockService = new Mock <IReminderService>();

            mockService.Setup(svc => svc.UpdateReminder(userId, reminder)).Returns(Task.FromResult(true));
            var controller = new ReminderController(mockService.Object);

            controller.ControllerContext = new ControllerContext {
                HttpContext = new DefaultHttpContext {
                    User = user
                }
            };

            var actual = await controller.Put(reminder);

            var actionresult = Assert.IsType <OkObjectResult>(actual);

            Assert.True(Convert.ToBoolean(actionresult.Value));
        }
        public void BuildWithPackageIdConstructor()
        {
            PackageId packageId             = new PackageId("myPackageId");
            ReminderScheduleBuilder builder = ReminderScheduleBuilder.ForPackageWithId(packageId);
            ReminderSchedule        built   = builder.Build();

            Assert.AreEqual(packageId, built.PackageId);
        }
        public void BuildWithStringConstructor()
        {
            String packageId = "myPackageId";
            ReminderScheduleBuilder builder = ReminderScheduleBuilder.ForPackageWithId(packageId);
            ReminderSchedule        built   = builder.Build();

            Assert.AreEqual(packageId, built.PackageId.Id);
        }
        public void BuildWithDefaultValues()
        {
            ReminderScheduleBuilder builder = ReminderScheduleBuilder.ForPackageWithId("whoCares");
            ReminderSchedule        built   = builder.Build();

            Assert.AreEqual(ReminderScheduleBuilder.DEFAULT_DAYS_BETWEEN_REMINDERS, built.DaysBetweenReminders);
            Assert.AreEqual(ReminderScheduleBuilder.DEFAULT_DAYS_UNTIL_FIRST_REMINDER, built.DaysUntilFirstReminder);
            Assert.AreEqual(ReminderScheduleBuilder.DEFAULT_NUMBER_OF_REPETITIONS, built.NumberOfRepetitions);
        }
Beispiel #9
0
        public Task <bool> UpdateReminder(string userId, ReminderSchedule reminder)
        {
            var result = _reminderRepository.UpdateReminder(userId, reminder);

            if (!result.Result)
            {
                throw new NoReminderFoundException("No reminder found for this news");
            }
            return(result);
        }
Beispiel #10
0
        public async Task UpdateReminderShouldFail()
        {
            string           userId   = "John";
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 102, Schedule = Convert.ToDateTime("2019-12-30")
            };
            var actual = await repository.UpdateReminder(userId, reminder);

            Assert.False(actual);
        }
        public async Task UpdateReminderShouldSuccess()
        {
            string           userId   = "John";
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 101, Schedule = DateTime.Now.AddDays(7)
            };
            var actual = await repository.UpdateReminder(userId, reminder);

            Assert.True(actual);
        }
Beispiel #12
0
        public Task <bool> CreateReminder(string userId, string email, ReminderSchedule schedule)
        {
            var reminders = _reminderRepository.IsReminderExists(userId, schedule.NewsId).Result;

            if (reminders)
            {
                throw new ReminderAlreadyExistsException($"This News already have a reminder");
            }
            _reminderRepository.CreateReminder(userId, email, schedule);
            return(Task.FromResult(true));
        }
Beispiel #13
0
 public ReminderSchedule SetReminderScheduleForPackage(ReminderSchedule reminderSchedule)
 {
     try {
         PackageReminderSchedule apiPayload = new ReminderScheduleConverter(reminderSchedule).ToAPIPackageReminderSchedule();
         string payload  = JsonConvert.SerializeObject(apiPayload, settings);
         string response = restClient.Post(Path(reminderSchedule.PackageId), payload);
         PackageReminderSchedule apiResponse = JsonConvert.DeserializeObject <PackageReminderSchedule> (response, settings);
         return(new ReminderScheduleConverter(apiResponse).ToSDKReminderSchedule());
     } catch (Exception e) {
         throw new EslException("Failed to set reminder schedule for package with id: " + reminderSchedule.PackageId.Id + ". Exception: " + e.Message);
     }
 }
        public async Task PutShouldReturnNotFound()
        {
            string userId = "Jack";
            ReminderSchedule reminder = new ReminderSchedule { NewsId = 102, Schedule = DateTime.Now.AddDays(2) };
            var mockService = new Mock<IReminderService>();
            mockService.Setup(svc => svc.UpdateReminder(userId, reminder)).Throws(new NoReminderFoundException("No reminder found for this news"));
            var controller = new ReminderController(mockService.Object);

            var actual = await controller.Put(userId, reminder);
            var actionResult = Assert.IsType<NotFoundObjectResult>(actual);
            Assert.Equal("No reminder found for this news", actionResult.Value);
        }
        public async Task PutShouldReturnOk()
        {
            string userId = "Jack";
            ReminderSchedule reminder = new ReminderSchedule { NewsId = 101, Schedule = DateTime.Now.AddDays(2) };
            var mockService = new Mock<IReminderService>();
            mockService.Setup(svc => svc.UpdateReminder(userId, reminder)).Returns(Task.FromResult(true));
            var controller = new ReminderController(mockService.Object);

            var actual = await controller.Put(userId, reminder);
            var actionresult = Assert.IsType<OkObjectResult>(actual);
            Assert.True(Convert.ToBoolean(actionresult.Value));
        }
Beispiel #16
0
        private Reminder.Schedule ScheduleFromProto(ReminderSchedule proto)
        {
            var repeatInterval = proto.RepeatInterval != 0
                ? (TimeSpan?)new TimeSpan(proto.RepeatInterval)
                : null;

            var ack = proto.Ack != null
                ? MessageFromProto(proto.Ack)
                : null;

            return(new Reminder.Schedule(proto.TaskId, ActorPathFromProto(proto.Recipient), MessageFromProto(proto.Payload), new DateTime(proto.TriggerDate), repeatInterval, ack));
        }
Beispiel #17
0
		public ReminderSchedule SetReminderScheduleForPackage( ReminderSchedule reminderSchedule )
		{
			try {
				PackageReminderSchedule apiPayload = new ReminderScheduleConverter(reminderSchedule).ToAPIPackageReminderSchedule();
				string payload = JsonConvert.SerializeObject (apiPayload, settings);
				string response = restClient.Post(Path(reminderSchedule.PackageId), payload);
				PackageReminderSchedule apiResponse = JsonConvert.DeserializeObject<PackageReminderSchedule> (response, settings );
				return new ReminderScheduleConverter( apiResponse ).ToSDKReminderSchedule();
			} catch (Exception e) {
				throw new EslException ("Failed to set reminder schedule for package with id: " + reminderSchedule.PackageId.Id + ". Exception: " + e.Message);
			}
		}
Beispiel #18
0
        /// <summary>
        /// Method for updating a reminder
        /// </summary>
        /// <param name="userId">The id of the user whose reminder is to be updated</param>
        /// <param name="reminder">The new details of the reminder to be applied</param>
        /// <returns>True if updation was successful</returns>
        public async Task <bool> UpdateReminder(string userId, ReminderSchedule reminder)
        {
            var updated = await reminderRepository.UpdateReminder(userId, reminder);

            if (updated)
            {
                return(updated);
            }
            else
            {
                throw new NoReminderFoundException("No reminder found for this news");
            }
        }
Beispiel #19
0
        /// <summary>
        /// Method for creating reminder
        /// </summary>
        /// <param name="userId">The user id against whom the reminder is to be added</param>
        /// <param name="email">The email of the user</param>
        /// <param name="schedule">The reminder details</param>
        /// <returns>True if creation successful</returns>
        public async Task <bool> CreateReminder(string userId, string email, ReminderSchedule schedule)
        {
            if (!await reminderRepository.IsReminderExists(userId, schedule.NewsId))
            {
                await reminderRepository.CreateReminder(userId, email, schedule);

                return(true);
            }
            else
            {
                throw new ReminderAlreadyExistsException($"This News already have a reminder");
            }
        }
        public void VerifyResult()
        {
            ReminderExample example = new ReminderExample(Props.GetInstance());

            example.Run();

            ReminderSchedule reminderSchedule = example.ReminderSchedule;

            Assert.IsNotNull(reminderSchedule);
            Assert.AreEqual(reminderSchedule.PackageId.Id, example.PackageId.Id);
            Assert.AreEqual(reminderSchedule.DaysUntilFirstReminder, 2);
            Assert.AreEqual(reminderSchedule.DaysBetweenReminders, 1);
            Assert.AreEqual(reminderSchedule.NumberOfRepetitions, 5);
        }
Beispiel #21
0
        public async Task AddReminderShouldSuccess()
        {
            string           userId   = "John";
            string           email    = "*****@*****.**";
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 101, Schedule = DateTime.Now
            };

            await repository.CreateReminder(userId, email, reminder);

            var status = await repository.IsReminderExists(userId, 101);

            Assert.True(status);
        }
        public async Task UpdateReminderShouldThrowException()
        {
            string           userId   = "Jack";
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 102, Schedule = DateTime.Now.AddHours(10)
            };
            var mockRepo = new Mock <IReminderRepository>();

            mockRepo.Setup(repo => repo.UpdateReminder(userId, reminder)).Returns(Task.FromResult(false));
            var service = new ReminderService.Services.ReminderService(mockRepo.Object);

            var actual = await Assert.ThrowsAsync <NoReminderFoundException>(() => service.UpdateReminder(userId, reminder));

            Assert.Equal("No reminder found for this news", actual.Message);
        }
Beispiel #23
0
 public async Task <IActionResult> Put(string userId, ReminderSchedule reminder)
 {
     try
     {
         return(Ok(await reminderService.UpdateReminder(userId, reminder)));
     }
     catch (NoReminderFoundException ex)
     {
         return(NotFound(ex.Message));
     }
     catch (Exception)
     {
         return(StatusCode(500, "Some error occurred, please try again!!"));
     }
 }
        public async Task UpdateReminderShouldSuccess()
        {
            string           userId   = "Jack";
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 101, Schedule = DateTime.Now.AddDays(3)
            };
            var mockRepo = new Mock <IReminderRepository>();

            mockRepo.Setup(repo => repo.UpdateReminder(userId, reminder)).Returns(Task.FromResult(true));
            var service = new ReminderService.Services.ReminderService(mockRepo.Object);

            var actual = await service.UpdateReminder(userId, reminder);

            Assert.True(actual);
        }
        public async Task AddReminderShouldThrowException()
        {
            string           userId   = "Jack";
            string           email    = "*****@*****.**";
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 101, Schedule = DateTime.Now.AddDays(3)
            };
            var mockRepo = new Mock <IReminderRepository>();

            mockRepo.Setup(repo => repo.IsReminderExists(userId, reminder.NewsId)).Returns(Task.FromResult(true));
            var service = new ReminderService.Services.ReminderService(mockRepo.Object);

            var actual = await Assert.ThrowsAsync <ReminderAlreadyExistsException>(() => service.CreateReminder(userId, email, reminder));

            Assert.Equal($"This News already have a reminder", actual.Message);
        }
        /// <summary>
        /// Method for updating a reminder
        /// </summary>
        /// <param name="userId">The id of the user whose reminder is to be updated</param>
        /// <param name="reminder">New properties of the reminder to be updated</param>
        /// <returns>True if updation successful</returns>
        public async Task <bool> UpdateReminder(string userId, ReminderSchedule reminder)
        {
            var builder = Builders <Reminder> .Filter;

            ///Filter for finding matching document
            var filter = builder.Eq(r => r.UserId, userId)
                         & builder.ElemMatch(r => r.NewsReminders, n => n.NewsId == reminder.NewsId);

            ///Update for setting the reminders value
            var update = Builders <Reminder> .Update.Set("NewsReminders.$.Schedule", reminder.Schedule);

            ///Update the reminder of the matching document with new value
            var result = await reminderContext.Reminders.UpdateOneAsync(filter, update);

            return(result.IsAcknowledged && result.ModifiedCount > 0);
        }
        public void ToAPIWithNoIDAndNoReminders()
        {
            ReminderSchedule sdk = new ReminderSchedule();

            sdk.NumberOfRepetitions    = 5;
            sdk.DaysUntilFirstReminder = 10;
            sdk.DaysBetweenReminders   = 15;
            PackageReminderSchedule api = new ReminderScheduleConverter(sdk).ToAPIPackageReminderSchedule();

            Assert.IsNotNull(api);
            Assert.AreEqual("", api.PackageId);
            Assert.AreEqual(5, api.RepetitionsCount);
            Assert.AreEqual(10, api.StartInDaysDelay);
            Assert.AreEqual(15, api.IntervalInDays);
            Assert.IsNotNull(api.Reminders);
            Assert.AreEqual(0, api.Reminders.Count);
        }
        public async Task AddReminderShouldReturnReminder()
        {
            string           userId   = "Jack";
            string           email    = "*****@*****.**";
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 102, Schedule = DateTime.Now.AddDays(1)
            };
            var mockRepo = new Mock <IReminderRepository>();

            mockRepo.Setup(repo => repo.IsReminderExists(userId, reminder.NewsId)).Returns(Task.FromResult(false));
            mockRepo.Setup(repo => repo.CreateReminder(userId, email, reminder));
            var service = new ReminderService.Services.ReminderService(mockRepo.Object);

            var actual = await service.CreateReminder(userId, email, reminder);

            Assert.True(actual);
        }
        public void BuildWithNonDefaultValues()
        {
            int daysBetweenReminders   = 10;
            int daysUntilFirstReminder = 100;
            int numberOfRepetitions    = 5;

            ReminderScheduleBuilder builder = ReminderScheduleBuilder.ForPackageWithId("whoCares")
                                              .WithDaysBetweenReminders(daysBetweenReminders)
                                              .WithDaysUntilFirstReminder(daysUntilFirstReminder)
                                              .WithNumberOfRepetitions(numberOfRepetitions);

            ReminderSchedule built = builder.Build();

            Assert.AreEqual(daysBetweenReminders, built.DaysBetweenReminders);
            Assert.AreEqual(daysUntilFirstReminder, built.DaysUntilFirstReminder);
            Assert.AreEqual(numberOfRepetitions, built.NumberOfRepetitions);
        }
Beispiel #30
0
        public async Task UpdateShouldReturnNotFound()
        {
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 102, Schedule = DateTime.Now.AddDays(3)
            };
            MediaTypeFormatter formatter = new JsonMediaTypeFormatter();

            // The endpoint or route of the controller action.
            var httpResponse = await _client.PutAsync($"/api/reminder", reminder, formatter);


            // Deserialize and examine results.
            var stringResponse = await httpResponse.Content.ReadAsStringAsync();

            Assert.Equal(HttpStatusCode.NotFound, httpResponse.StatusCode);
            Assert.Equal("No reminder found for this news", stringResponse);
        }
Beispiel #31
0
        public async Task UpdateShouldSuccess()
        {
            ReminderSchedule reminder = new ReminderSchedule {
                NewsId = 101, Schedule = DateTime.Now.AddDays(3)
            };
            MediaTypeFormatter formatter = new JsonMediaTypeFormatter();

            // The endpoint or route of the controller action.
            var httpResponse = await _client.PutAsync($"/api/reminder", reminder, formatter);

            // Must be successful.
            httpResponse.EnsureSuccessStatusCode();

            // Deserialize and examine results.
            var stringResponse = await httpResponse.Content.ReadAsStringAsync();

            Assert.True(Convert.ToBoolean(stringResponse));
        }
		public ReminderSchedule SetReminderScheduleForPackage( ReminderSchedule reminderSchedule )
		{
			PackageReminderSchedule apiPayload = new ReminderScheduleConverter(reminderSchedule).ToAPIPackageReminderSchedule();
            PackageReminderSchedule apiResponse = apiClient.SetReminderScheduleForPackage(apiPayload);
			return new ReminderScheduleConverter( apiResponse ).ToSDKReminderSchedule();
		}