Ejemplo n.º 1
0
        /// <summary>
        /// Добавляет измененное правило.
        /// Вызывается из метода Execute класса ModificationsRuleHandler
        /// </summary>
        /// <param name="request"></param>
        public void AddModifiedRule(TypiconEntity typicon, ModificationsRuleRequest request)
        {
            ModifiedYear modifiedYear = typicon.ModifiedYears.FirstOrDefault(m => m.Year == request.Date.Year);

            if (modifiedYear == null)
            {
                modifiedYear = new ModifiedYear()
                {
                    Year = request.Date.Year, TypiconEntity = typicon
                };
                typicon.ModifiedYears.Add(modifiedYear);
            }

            //ModifiedRule

            modifiedYear.ModifiedRules.Add(new ModifiedRule()
            {
                Date        = request.Date,
                RuleEntity  = request.Caller,
                Priority    = request.Priority,
                IsLastName  = request.IsLastName,
                IsAddition  = request.AsAddition,
                ShortName   = request.ShortName,
                UseFullName = request.UseFullName
            });
        }
Ejemplo n.º 2
0
        public void Typicon_TypiconVersion_ModifiedYear()
        {
            TypiconVersion typicon = new TypiconVersion();

            ModifiedYear year = typicon.ModifiedYears.FirstOrDefault(c => c.Year == 2017);

            Assert.IsNull(year);
        }
Ejemplo n.º 3
0
        public ModificationsRuleHandler(TypiconDBContext dbContext, int typiconVersionId, ModifiedYear modifiedYear)
        {
            _dbContext        = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
            _typiconVersionId = typiconVersionId;
            _modifiedYear     = modifiedYear ?? throw new ArgumentNullException(nameof(modifiedYear));

            AuthorizedTypes = new List <Type>()
            {
                typeof(ModifyDay)
            };
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Возвращает список измененных правил для конкретной даты
        /// </summary>
        /// <param name="date">Конкретная дата</param>
        /// <returns></returns>
        public IEnumerable <ModifiedRule> GetModifiedRules(TypiconEntity typicon, DateTime date)
        {
            ModifiedYear modifiedYear = typicon.ModifiedYears.FirstOrDefault(m => m.Year == date.Year);

            if (modifiedYear == null)
            {
                modifiedYear = CreateModifiedYear(typicon, date);

                typicon.ModifiedYears.Add(modifiedYear);

                //_unitOfWork.Commit();
            }

            return(modifiedYear.ModifiedRules.FindAll(d => d.Date.Date == date.Date));
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Возвращает список измененных правил для конкретной даты
        /// </summary>
        /// <param name="date">Конкретная дата</param>
        /// <returns></returns>
        public static IEnumerable <ModifiedRule> GetModifiedRules(this TypiconEntity typicon, DateTime date, IRuleSerializerRoot serializer)
        {
            ModifiedYear modifiedYear = typicon.ModifiedYears.FirstOrDefault(m => m.Year == date.Year);

            if (modifiedYear == null)
            {
                modifiedYear = CreateModifiedYear(typicon, date, serializer);

                //typicon.ModifiedYears.Add(modifiedYear);

                //_unitOfWork.Commit();
            }

            return(modifiedYear.ModifiedRules.Where(d => d.Date.Date == date.Date));
        }
        protected virtual ModifiedYear InnerCreate(int typiconVersionId, int year)
        {
            var modifiedYear = new ModifiedYear()
            {
                Year = year,
                TypiconVersionId = typiconVersionId,
                IsCalculated = false
            };

            //await _dbContext.UpdateModifiedYearAsync(modifiedYear);

            Fill(typiconVersionId, modifiedYear);

            modifiedYear.IsCalculated = true;

            return modifiedYear;
        }
Ejemplo n.º 7
0
        public static async Task UpdateModifiedYearAsync(this TypiconDBContext dbContext, ModifiedYear modifiedYear)
        {
            dbContext.Set <ModifiedYear>().Update(modifiedYear);

            await dbContext.SaveChangesAsync();
        }
Ejemplo n.º 8
0
        public static void UpdateModifiedYear(this TypiconDBContext dbContext, ModifiedYear modifiedYear)
        {
            dbContext.Set <ModifiedYear>().Update(modifiedYear);

            dbContext.SaveChanges();
        }
Ejemplo n.º 9
0
        private ModifiedYear CreateModifiedYear(TypiconEntity typicon, DateTime date)
        {
            //По умолчанию добавляем год, пусть он и останется пустым
            ModifiedYear modifiedYear = new ModifiedYear()
            {
                Year = date.Year
            };

            DateTime indexDate = new DateTime(date.Year, 1, 1);

            //формируем список дней для изменения до 1 января будущего года
            DateTime endDate = new DateTime(date.Year + 1, 1, 1);

            while (indexDate != endDate)
            {
                //Menology

                //находим правило для конкретного дня Минеи
                MenologyRule menologyRule = typicon.GetMenologyRule(indexDate);

                if (menologyRule == null)
                {
                    throw new ArgumentNullException("MenologyRule");
                }

                InterpretMenologyRule(menologyRule, indexDate, date.Year);

                indexDate = indexDate.AddDays(1);
            }

            //теперь обрабатываем переходящие минейные праздники
            //у них не должны быть определены даты. так их и найдем

            typicon.MenologyRules.FindAll(c => (c.Date.IsEmpty && c.DateB.IsEmpty)).
            ForEach(a =>
            {
                InterpretMenologyRule(a, date, date.Year);

                //не нашел другого способа, как только два раза вычислять изменяемые дни
                InterpretMenologyRule(a, date.AddYears(1), date.Year);
            });

            //Triodion

            //найти текущую Пасху
            //Для каждого правила выполнять interpret(), где date = текущая Пасха. AddDays(Day.DaysFromEaster)
            DateTime easter = Serializer.BookStorage.Easters.GetCurrentEaster(date.Year);

            typicon.TriodionRules.
            ForEach(a =>
            {
                RuleElement rule = a.GetRule(Serializer);
                if (rule != null)
                {
                    ModificationsRuleHandler handler = new ModificationsRuleHandler(
                        new RuleHandlerSettings(a), date.Year);

                    int i = a.DaysFromEaster;
                    rule.Interpret(easter.AddDays(i), handler);
                }
            });

            return(modifiedYear);

            void InterpretMenologyRule(MenologyRule menologyRule, DateTime dateToInterpret, int year)
            {
                if (menologyRule != null)
                {
                    ModificationsRuleHandler handler = new ModificationsRuleHandler(
                        new RuleHandlerSettings(menologyRule), year);
                    //выполняем его
                    menologyRule.GetRule(Serializer).Interpret(dateToInterpret, handler);
                }
            }
        }
        protected virtual void Fill(int typiconVersionId, ModifiedYear modifiedYear)
        {
            var handler = new ModificationsRuleHandler(_dbContext, typiconVersionId, modifiedYear);

            //MenologyRules

            var menologyRules = _dbContext.GetAllMenologyRules(modifiedYear.TypiconVersionId);

            EachDayPerYear.Perform(modifiedYear.Year, date =>
            {
                //находим правило для конкретного дня Минеи
                var menologyRule = menologyRules.GetMenologyRule(date);

                InterpretRule(menologyRule, date, handler);
            });

            //теперь обрабатываем переходящие минейные праздники
            //у них не должны быть определены даты. так их и найдем
            var rules = menologyRules.GetAllMovableRules();

            var firstJanuary = new DateTime(modifiedYear.Year, 1, 1);

            foreach (var a in rules)
            {
                InterpretRule(a, firstJanuary, handler);

                //не нашел другого способа, как только два раза вычислять изменяемые дни
                InterpretRule(a, firstJanuary.AddYears(1), handler);
            }

            //Triodion

            //найти текущую Пасху
            //Для каждого правила выполнять interpret(), где date = текущая Пасха. AddDays(Day.DaysFromEaster)
            DateTime easter = _dbContext.GetCurrentEaster(modifiedYear.Year);

            var triodionRules = _dbContext.GetAllTriodionRules(modifiedYear.TypiconVersionId);

            foreach (var triodionRule in triodionRules)
            {
                InterpretRule(triodionRule, easter.AddDays(triodionRule.DaysFromEaster), handler);
            }

            void InterpretRule(DayRule rule, DateTime dateToInterpret, ModificationsRuleHandler h)
            {
                if (rule != null)
                {
                    h.ProcessingDayRule = rule;

                    var r = _settingsFactory.CreateRecursive(new CreateRuleSettingsRequest()
                    {
                        TypiconVersionId = modifiedYear.TypiconVersionId,
                        Rule = rule,
                        Date = dateToInterpret,
                        RuleMode = RuleMode.ModRule
                    });

                    if (r.Success)
                    {
                        h.Settings = r.Value;

                        //выполняем его
                        h.Settings?.RuleContainer.Interpret(h);
                    }
                }
            }
        }