public IEnumerable <IScheduledValidation> AddValidationsToSchedule(IEnumerable <IScheduleRequest> scheduleRequests)
        {
            Guard.NotNull(scheduleRequests, "scheduleRequests", log);
            this.ValidateScheduledRequestsInputNotNull(scheduleRequests);

            //TODO when UI ready need to figure out pattern for errors. Add all properly formated scheduleRequests. Return a list of the failed and successful validations to show user.
            //Right now the first invalid validation will throw an error.

            log.Info("HangFireScheduler AddValidationsToSchedule starting for {ScheduleCount}", scheduleRequests.Count());

            List <IScheduledValidation> results = new List <IScheduledValidation>();

            foreach (IScheduleRequest scheduleRequest in scheduleRequests)
            {
                IScheduledValidation scheduledValidation = this.AddValidationToSchedule(scheduleRequest);

                results.Add(scheduledValidation);
#if DEBUG
                JobsScheduled++;
#endif
            }

#if DEBUG
            //for (int i = 0; i < 50; i++)
            //{
            //    foreach (IScheduleRequest scheduleRequest in scheduleRequests)
            //    {
            //        var jobId = this.ValidateAndGetJobId(scheduleRequest.ValidatorId, scheduleRequest.ValidatorInstanceId);
            //        RecurringJob.Trigger(jobId);
            //    }
            //}
#endif

            return(results);
        }
        private void ValidateScheduledRequest(IScheduleRequest scheduleRequest, IScheduledValidation scheduledValidation)
        {
            var jobId        = scheduledValidation.JobId;
            var instanceInfo = JobIdUtils.GetInstanceInfo(jobId);

            Assert.Equal(scheduleRequest.ValidatorId, instanceInfo.ValidatorId);
            Assert.Equal(scheduleRequest.ValidatorInstanceId, instanceInfo.ValidatorInstanceId);
        }
        public void HangFireItemScheduledSuccessfully(string validatorId, string validatorInstanceId)
        {
            IScheduleRequest     scheduleRequest     = new ScheduleRequest(validatorId, validatorInstanceId, CronTabExpressionRunHourly);
            IScheduledValidation scheduledValidation = this._hangFireScheduler.AddValidationToSchedule(scheduleRequest);
            var scheduledValidations = this._hangFireScheduler.GetScheduledValidations();
            var isScheduled          = this._hangFireScheduler.IsValidationScheduled(validatorId, validatorInstanceId);

            Assert.Equal(scheduledValidation.JobId, JobIdUtils.GetJobId(validatorId, validatorInstanceId));
            Assert.Equal(1, scheduledValidations.Count());
            Assert.True(isScheduled);
        }
        public IScheduledValidation AddValidationToSchedule(IScheduleRequest scheduleRequest)
        {
            Guard.NotNull(scheduleRequest, "scheduleRequest", log);

            log.Debug("HangFireScheduler AddValidationToSchedule for validationId {ValidatorId} validationInstanceId {ValidatorInstanceId} cronTabExpressions {CronTabExpression}",
                      scheduleRequest.ValidatorId, scheduleRequest.ValidatorInstanceId, scheduleRequest.CronTabExpression);

            IScheduledValidation scheduledValidation = this.AddOrEditValidationSchedule(scheduleRequest);

            return(scheduledValidation);
        }
        public void HangFireItemRemoveScheduledItemSucceeds([Frozen] string validatorId, [Frozen] string validatorInstanceId)
        {
            IScheduleRequest     scheduleRequest = new ScheduleRequest(validatorId, validatorInstanceId, CronTabExpressionRunHourly);
            IScheduledValidation val             = this._hangFireScheduler.AddValidationToSchedule(scheduleRequest);

            var scheduledValidations = this._hangFireScheduler.GetScheduledValidations();

            Assert.Equal(1, scheduledValidations.Count());

            this._hangFireScheduler.RemoveValidationFromSchedule(validatorId, validatorInstanceId);
            scheduledValidations = this._hangFireScheduler.GetScheduledValidations();
            var isScheduled = this._hangFireScheduler.IsValidationScheduled(validatorId, validatorInstanceId);

            Assert.Equal(0, scheduledValidations.Count());
            Assert.False(isScheduled);
        }
        public SchedulableValidator(string validatorId, string validatorInstanceId, bool isScheduled = false, IScheduledValidation scheduledValidation = null)
        {
            this.ValidatorId         = Guard.NotNullOrEmpty(validatorId, "validatorId", log);
            this.ValidatorInstanceId = Guard.NotNullOrEmpty(validatorInstanceId, "validatorInstanceId", log);

            this.IsScheduled         = isScheduled;
            this.ScheduledValidation = scheduledValidation;
        }
Example #7
0
        //add
        //delete
        //modify
        //get list


        public void AddScheduledValidation(IScheduledValidation scheduleRequest)
        {
            throw new NotImplementedException();
        }