示例#1
0
        private void parseCalendars(XElement doc)
        {
            XNamespace ns        = doc.GetDefaultNamespace();
            var        calendars = doc.Descendants(ns + "calendars").Elements();

            foreach (var calendarXml in calendars)
            {
                string    type     = calendarXml.Name.LocalName;
                ICalendar calendar = null;
                switch (type)
                {
                case "cronCalendar":
                    calendar = parseCronCalendar(calendarXml);
                    break;

                case "dailyCalendar":
                    calendar = parseDailyCalendar(calendarXml);
                    break;

                default:
                    throw new ArgumentOutOfRangeException(string.Format("Calendar type {0} is not supported", type));
                }
                string calendarName = parseCalendarName(calendarXml);
                Scheduler.AddCalendar(calendarName, calendar, parseReplaceCalendar(calendarXml), parseUpdateTriggers(calendarXml));
                Calendars.Add(parseCalendarName(calendarXml), calendar);
            }
        }
示例#2
0
        /// <summary>
        /// 添加日历
        /// </summary>
        /// <param name="input"></param>
        public static void AddCalendar(CalendarInput input)
        {
            var calendar = new BaseCalendar();

            switch (input.EnumCalendar)
            {
            case EnumCalendar.Cron表达式:
                calendar = new CronCalendar(input.Expression);
                break;
            }
            calendar.TimeZone    = TimeZoneInfo.Local;
            calendar.Description = input.Description;
            Scheduler.AddCalendar(input.CalendarName, calendar, input.ReplaceExists, input.UpdateTriggers);
        }
示例#3
0
        public async Task <IActionResult> Save([FromBody] CalendarViewModel[] chain, bool isNew)
        {
            var result = new ValidationResult();

            if (chain.Length == 0 || string.IsNullOrEmpty(chain[0].Name))
            {
                result.Errors.Add(ValidationError.EmptyField(nameof(CalendarViewModel.Name)));
            }

            for (int i = 0; i < chain.Length; i++)
            {
                RemoveLastEmpty(chain[i].Days);
                RemoveLastEmpty(chain[i].Dates);

                var errors = new List <ValidationError>();
                chain[i].Validate(errors);
                errors.ForEach(x => x.SegmentIndex = i);
                result.Errors.AddRange(errors);
            }

            if (result.Success)
            {
                string name = chain[0].Name;

                ICalendar existing = null;

                if (isNew == false)
                {
                    existing = await Scheduler.GetCalendar(name);
                }

                ICalendar root = null, current = null;
                for (int i = 0; i < chain.Length; i++)
                {
                    ICalendar newCal = chain[i].Type.Equals("custom") ? existing : chain[i].BuildCalendar();

                    if (newCal == null)
                    {
                        break;
                    }

                    if (i == 0)
                    {
                        root = newCal;
                    }
                    else
                    {
                        current.CalendarBase = newCal;
                    }

                    current  = newCal;
                    existing = existing?.CalendarBase;
                }

                if (root == null)
                {
                    result.Errors.Add(new ValidationError {
                        Field = nameof(CalendarViewModel.Type), Reason = "Cannot create calendar.", SegmentIndex = 0
                    });
                }
                else
                {
                    await Scheduler.AddCalendar(name, root, replace : true, updateTriggers : true);
                }
            }

            return(Json(result));
        }