protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsAuthorized <TextHolder>())
{
handler.Execute(this);
}
}
/// <summary>
/// Добавляет в конец коллекции вычисляемых канонов катавасию
/// </summary>
/// <param name="date"></param>
/// <param name="handler"></param>
/// <param name="container"></param>
private void CalculateKatavasiaStructure(IRuleHandler handler, ExecContainer container)
{
if (container?.ChildElements.FirstOrDefault() is KKatavasiaRule item)
{
_kanonesCalc.Add(item.Calculate(handler.Settings) as Kanonas);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsAuthorized <KekragariaRule>())
{
base.InnerInterpret(handler);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsAuthorized <KanonasRule>())
{
///используем специальный обработчик для KKatavasiaRule
var katavasiaContainer = GetChildElements <KKatavasiaRule>(handler);
//используем специальный обработчик для KanonasItem,
//чтобы создать список источников канонов на обработку
var kanonasItemContainer = GetChildElements <KKanonasItemRule>(handler);
if (kanonasItemContainer != null)
{
CalculateOdesStructure(handler, kanonasItemContainer, (katavasiaContainer != null));
}
if (katavasiaContainer != null)
{
CalculateKatavasiaStructure(handler, katavasiaContainer);
}
//находим KAfterRules
var afterContainer = GetChildElements <KAfterRule>(handler);
if (afterContainer != null)
{
AfterRules = afterContainer.ChildElements.Cast <KAfterRule>();
}
handler.Execute(this);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsTypeAuthorized(this) && !this.AsAdditionHandled(handler))
{
//Добавляем IAsAdditionElement append реализацию
//Приходится явно вызывать метод, т.к. функционал ExecContainer.InnerInterpret не используется
var appended = AppendHandling(handler);
Odes = GetChildElements <KOdiRule>(handler.Settings);
AfterRules = GetChildElements <KAfterRule>(handler.Settings);
foreach (var ode in Odes)
{
ode.Interpret(handler);
}
//обрабатываем AfterRules только если это не расписание
if (!(handler is ScheduleHandler))
{
foreach (var afterRule in AfterRules)
{
afterRule.Interpret(handler);
}
}
//и сразу же удаляем appended IAsAdditionElements
RemoveAppended(appended);
handler.Execute(this);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
foreach (RuleElement el in ChildElements)
{
el.Interpret(handler);
}
}
/// <summary>
/// Общедоступный метод вызова интерпретации правила
/// </summary>
/// <param name="date"></param>
/// <param name="handler"></param>
public virtual void Interpret(IRuleHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException("IRuleHandler in Interpret");
}
if (handler.Settings == null)
{
throw new ArgumentNullException("handler.Settings in Interpret");
}
//Проверка для всех элементов правил.
//Если неверно составлен, то либо выкидывается исключение (в случае соответствующей настройки),
//либо просто ничего не обрабатывается
if (ThrowExceptionIfInvalid(handler.Settings))
{
return;
}
handler.Settings.ApplyCustomParameters(this);
if (handler.Settings.CheckCustomParameters(this))
{
InnerInterpret(handler);
}
}
private string GetKindStringValue(TextHolderKind kind, IRuleHandler handler)
{
CommonRuleServiceRequest req = new CommonRuleServiceRequest()
{
RuleSerializer = Serializer
};
switch (kind)
{
case TextHolderKind.Choir:
req.Key = CommonRuleConstants.ChoirRule;
break;
case TextHolderKind.Deacon:
req.Key = CommonRuleConstants.DeaconRule;
break;
case TextHolderKind.Lector:
req.Key = CommonRuleConstants.LectorRule;
break;
case TextHolderKind.Priest:
req.Key = CommonRuleConstants.PriestRule;
break;
case TextHolderKind.Stihos:
req.Key = CommonRuleConstants.StihosRule;
break;
default:
return(string.Empty);
}
return(handler.Settings.Rule.Owner.GetCommonRuleTextValue(req, handler.Settings.Language));
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsTypeAuthorized(this))
{
base.InnerInterpret(handler);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsAuthorized <KanonasItemRuleBase>())
{
handler.Execute(this);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsTypeAuthorized(this))
{
//находим переменную
var query = SerializerRoot.QueryProcessor.Process(new TypiconVariableQuery(handler.Settings.TypiconVersionId, VariableName));
//если найдена и у нее определено Значение
if (query.Value is TypiconVariable var &&
!string.IsNullOrEmpty(var.Value))
{
//десериализуем
var container = SerializerRoot.Container <ExecContainer>().Deserialize(var.Value);
if (container != null)
{
//находим все службы
foreach (var worship in container.GetChildElements <WorshipRule>(handler.Settings))
{
//обрабатываем их
handler.Execute(worship);
}
}
}
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsTypeAuthorized(this))
{
handler.Execute(this);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsAuthorized <KSedalenRule>())
{
handler.Execute(this);
}
}
protected override void InnerInterpret(IRuleHandler settings)
{
foreach (RuleExpression valueElement in ValuesElements)
{
valueElement.Interpret(settings);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
ChildExpression.Interpret(handler);
DateTime easterDate = easterContext.GetCurrentEaster(handler.Settings.Date.Year);
ValueCalculated = easterDate.AddDays((int)ChildExpression.ValueCalculated);
}
protected override void InnerInterpret(IRuleHandler handler)
{
ChildExpression.Interpret(handler);
DateTime easterDate = queryProcessor.Process(new CurrentEasterQuery(handler.Settings.Date.Year));
ValueCalculated = easterDate.AddDays((int)ChildExpression.ValueCalculated);
}
public OdiViewModelFactory(IRuleHandler handler, IRuleSerializerRoot serializer, Action <OutputSectionModelCollection> appendModelAction)
{
this.handler = handler ?? throw new ArgumentNullException("IRuleHandler in OdiViewModelHandler");
this.appendModelAction = appendModelAction ?? throw new ArgumentNullException("Action<ElementViewModel> in OdiViewModelHandler");
this.serializer = serializer ?? throw new ArgumentNullException("IRuleSerializerRoot in OdiViewModelHandler");
choruses = serializer.GetCommonRuleChildren <TextHolder>(handler.Settings.TypiconVersionId, CommonRuleConstants.KanonasChorusRule);
}
protected override void InnerInterpret(IRuleHandler handler)
{
//если значение выражения пустое, просто передаем текущую дату
//из вводимой даты берем только год
ValueCalculated = (ValueExpression.IsEmpty)
? handler.Settings.Date
: new DateTime(handler.Settings.Date.Year, ValueExpression.Month, ValueExpression.Day);
}
protected static string GetKindStringValue(ViewModelItemKind kind, IRuleHandler handler, IRuleSerializerRoot ruleSerializer)
{
string result = "";
int index = -1;
switch (kind)
{
case ViewModelItemKind.Choir:
index = 0;
break;
case ViewModelItemKind.Deacon:
index = 1;
break;
case ViewModelItemKind.Lector:
index = 2;
break;
case ViewModelItemKind.Priest:
index = 3;
break;
case ViewModelItemKind.Stihos:
index = 4;
break;
case ViewModelItemKind.Irmos:
index = 5;
break;
case ViewModelItemKind.Troparion:
index = 6;
break;
case ViewModelItemKind.Chorus:
index = 7;
break;
case ViewModelItemKind.Theotokion:
index = 8;
break;
//default:
// return string.Empty;
}
if (index >= 0)
{
result = handler.Settings.Rule.Owner.GetCommonRuleIndexedString(
new CommonRuleServiceRequest()
{
Key = CommonRuleConstants.ViewModelKind, RuleSerializer = ruleSerializer
}, index, handler.Settings.Language.Name);
}
return(result);
}
public void CreateViewModel(IRuleHandler handler, Action <ElementViewModel> append)
{
ViewModelFactory.Create(new CreateViewModelRequest <TextHolder>()
{
Element = this,
Handler = handler,
AppendModelAction = append
});
}
private static void Rewrite(IAsAdditionElement found, IRuleHandler handler)
{
var currentsettings = handler.Settings;
handler.Settings = currentsettings.Addition;
(found as RuleElementBase).Interpret(handler);
handler.Settings = currentsettings;
}
public void CreateViewModel(IRuleHandler handler, Action <OutputSectionModelCollection> append)
{
ViewModelFactory.Create(new CreateViewModelRequest <KontakionRule>()
{
Element = this,
Handler = handler,
AppendModelAction = append
});
}
private static (ItemText StihosText, ItemText ChoirText) GetStringValues(IRuleHandler handler, IRuleSerializerRoot serializer)
{
//находим Стих и Хор для дальнешей вставки
var stihos = serializer.GetCommonRuleItemTextValue(handler.Settings.TypiconVersionId, CommonRuleConstants.StihosRule);
var choir = serializer.GetCommonRuleItemTextValue(handler.Settings.TypiconVersionId, CommonRuleConstants.ChoirRule);
return(stihos, choir);
}
public virtual void CreateViewModel(IRuleHandler handler, Action <OutputSectionModelCollection> append)
{
ViewModelFactory.Create(new CreateViewModelRequest <YmnosStructureRule>()
{
Element = this,
Handler = handler,
AppendModelAction = append
});
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsAuthorized <KAfterRule>())
{
base.InnerInterpret(handler);
handler.Execute(this);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsTypeAuthorized(this) && !this.AsAdditionHandled(handler))
{
base.InnerInterpret(handler);
handler.Execute(this);
}
}
protected override void InnerInterpret(IRuleHandler handler)
{
if (handler.IsAuthorized <Notice>())
{
handler.Execute(this);
//base.Interpret(date, handler);
}
}
public virtual void CreateViewModel(IRuleHandler handler, Action <ElementViewModel> append)
{
ViewModelFactory.Create(new CreateViewModelRequest <KanonasRule>()
{
Element = this,
Handler = handler,
AppendModelAction = append
});
}
public static void AppendViewModel(this ItemText text, IRuleHandler handler, OutputSectionModelCollection viewModel)
{
if (text?.IsEmpty == false)
{
viewModel.Add(OutputSectionFactory.Create(TextHolderKind.Text,
new List <ItemTextNoted> {
new ItemTextNoted(text)
}));
}
}
public static void AppendViewModel(this ItemText text, IRuleHandler handler, ElementViewModel viewModel)
{
if (text?.IsEmpty == false)
{
viewModel.Add(ViewModelItemFactory.Create(TextHolderKind.Text,
new List <ParagraphViewModel> {
ParagraphVMFactory.Create(text, handler.Settings.Language.Name)
}));
}
}
public static IEnumerable<string> GetRuleLines(IRuleHandler profile)
{
return
(profile.DecodedRules ?? string.Empty).Split(Environment.NewLine.ToCharArray()).Where(x => !string.IsNullOrEmpty(x));
}
