示例#1
0
        private Result <RuleHandlerSettings> InnerCreate(CreateRuleSettingsRequest req, RootContainer container)
        {
            var settings = new RuleHandlerSettings()
            {
                Addition         = req.AdditionalSettings,
                TypiconVersionId = req.TypiconVersionId,
                Date             = req.Date,
                RuleContainer    = container,
                PrintDayTemplate = req.PrintDayTemplate,
                ApplyParameters  = req.ApplyParameters,
                CheckParameters  = req.CheckParameters,
                OktoikhDay       = req.OktoikhDay,
            };

            if (req.Menologies != null)
            {
                settings.Menologies = req.Menologies.ToList();
            }

            if (req.Triodions != null)
            {
                settings.Triodions = req.Triodions.ToList();
            }

            return(Result.Ok(settings));
        }
        public Result <RuleHandlerSettings> CreateRecursive(CreateRuleSettingsRequest request)
        {
            //обрабатываем только последовательности богослужений, не "переходящие" последовательности
            if (request.RuleMode == RuleMode.ModRule)
            {
                return(Decoratee(request));
            }

            var settings = _dbContext.Set <ScheduleSettings>()
                           .FirstOrDefault(c => c.TypiconVersionId == request.TypiconVersionId);

            if (settings != null)
            {
                bool success = FromDaysOfWeek(settings, request) ||
                               FromSigns(settings, request) ||
                               FromMenologies(settings, request) ||
                               FromTriodions(settings, request) ||
                               FromIncluded(settings, request);

                //exclude
                success = success && FromExcluded(settings, request);

                if (success)
                {
                    return(Decoratee(request));
                }
            }

            return(Result.Fail <RuleHandlerSettings>(""));
        }
示例#3
0
        /// <summary>
        /// Создает настройки для IRuleHandler
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        public virtual Result <RuleHandlerSettings> CreateRecursive(CreateRuleSettingsRequest req)
        {
            if (req == null)
            {
                throw new ArgumentNullException(nameof(req));
            }

            (ITemplateHavingEntity existingRule, RootContainer container) = GetFirstExistingRule(req.Rule, req.RuleMode);

            if (existingRule != null)
            {
                var settings = InnerCreate(req, container);

                if (existingRule.IsAddition && existingRule.Template != null)
                {
                    req.Rule = existingRule.Template;

                    settings = CreateRecursive(req);
                }

                return(settings);
            }

            return(Result.Fail <RuleHandlerSettings>(""));
        }
 /// <summary>
 /// Из выбранных дней недели
 /// </summary>
 /// <param name="s"></param>
 /// <param name="r"></param>
 /// <returns></returns>
 private bool FromDaysOfWeek(ScheduleSettings s, CreateRuleSettingsRequest r)
 {
     return((s.IsMonday && r.Date.DayOfWeek == DayOfWeek.Monday) ||
            (s.IsTuesday && r.Date.DayOfWeek == DayOfWeek.Tuesday) ||
            (s.IsWednesday && r.Date.DayOfWeek == DayOfWeek.Wednesday) ||
            (s.IsThursday && r.Date.DayOfWeek == DayOfWeek.Thursday) ||
            (s.IsFriday && r.Date.DayOfWeek == DayOfWeek.Friday) ||
            (s.IsSaturday && r.Date.DayOfWeek == DayOfWeek.Saturday) ||
            (s.IsSunday && r.Date.DayOfWeek == DayOfWeek.Sunday));
 }
 /// <summary>
 /// Из правил триоди
 /// </summary>
 /// <param name="settings"></param>
 /// <param name="request"></param>
 /// <returns></returns>
 private bool FromTriodions(ScheduleSettings settings, CreateRuleSettingsRequest request)
 {
     return((request.Rule is TriodionRule triodion) &&
            (settings.TriodionRules.Any(c => c.Rule == triodion)));
 }
 /// <summary>
 /// Из включенных дат
 /// </summary>
 /// <param name="settings"></param>
 /// <param name="request"></param>
 /// <returns></returns>
 private bool FromIncluded(ScheduleSettings settings, CreateRuleSettingsRequest request)
 {
     return(settings.IncludedDates.Any(c => c.Date == request.Date.Date));
 }
 /// <summary>
 /// Из исключенных дат
 /// </summary>
 /// <param name="settings"></param>
 /// <param name="request"></param>
 /// <returns></returns>
 private bool FromExcluded(ScheduleSettings settings, CreateRuleSettingsRequest request)
 {
     return(!settings.ExcludedDates.Contains(request.Date.Date));
 }
 private Result <RuleHandlerSettings> Decoratee(CreateRuleSettingsRequest request) => _decoratee.CreateRecursive(request);
 /// <summary>
 /// Из Знаков службы
 /// </summary>
 /// <param name="settings"></param>
 /// <param name="request"></param>
 /// <returns></returns>
 private bool FromSigns(ScheduleSettings settings, CreateRuleSettingsRequest request)
 {
     return(settings.Signs
            .Any(c => c.Rule == request.Rule.Template));
 }
 /// <summary>
 /// Из правил минеи
 /// </summary>
 /// <param name="settings"></param>
 /// <param name="request"></param>
 /// <returns></returns>
 private bool FromMenologies(ScheduleSettings settings, CreateRuleSettingsRequest request)
 {
     return((request.Rule is MenologyRule menology) &&
            (settings.MenologyRules.Any(c => c.Rule == menology)));
 }