public override void ExecuteRule(LogicRuleInfo <IAdditionalViewControlsRule> info, ExecutionContext executionContext)
{
if (Frame != null)
{
var viewSiteTemplate = Frame.Template as IViewSiteTemplate;
if (viewSiteTemplate == null)
{
return;
}
object viewSiteControl = GetContainerControl(viewSiteTemplate, info.Rule);
if (viewSiteControl != null)
{
IAdditionalViewControlsRule additionalViewControlsRule = info.Rule;
var calculator = new AdditionalViewControlsProviderCalculator(additionalViewControlsRule, info.View.ObjectTypeInfo.Type);
Type controlType = calculator.ControlsRule.ControlType;
ICollection controls = GetControls(viewSiteControl);
IAdditionalViewControl additionalViewControl = FindControl(info.Rule, controls);
if (info.Active && ViewContextIsCorrect(info.Rule))
{
var control = GetControl(controlType, additionalViewControl, info);
control.Rule = info.Rule;
ReflectionHelper.CreateObject(calculator.ControlsRule.DecoratorType, new[] { info.View, (object)control, info.Rule });
if (additionalViewControl == null)
{
AddControl(control, controls, info);
InitializeControl(control, info, calculator, executionContext);
}
}
else if (additionalViewControl != null)
{
controls.GetType().GetMethod("Remove").Invoke(controls, new[] { additionalViewControl });
}
}
}
}
protected virtual void RemoveControl(IList controls, object firstOrDefault, LogicRuleInfo <IAdditionalViewControlsRule> info)
{
if (info.Rule.Position != Position.DetailViewItem)
{
controls.Remove(firstOrDefault);
}
}
public override void ExecuteRule(LogicRuleInfo <IConditionalDetailViewRule> info, ExecutionContext executionContext)
{
if (info.Active && !info.InvertingCustomization)
{
if (executionContext == ExecutionContext.CustomProcessSelectedItem)
{
_ruleForCustomProcessSelectedItem = info.Rule;
}
else if (executionContext == ExecutionContext.CurrentObjectChanged)
{
_previousModel = View.Model;
View.SetModel(info.Rule.DetailView);
if (!defaultValuesRulesStorage.ContainsKey(info.Rule))
{
defaultValuesRulesStorage.Add(info.Rule, info.Rule.View);
}
info.Rule.View = info.Rule.DetailView;
}
else if (executionContext == ExecutionContext.ViewShowing || info.Action == Frame.GetController <NewObjectViewController>().NewObjectAction)
{
info.View.SetModel(info.Rule.DetailView);
}
}
else if (info.InvertingCustomization)
{
if (executionContext == ExecutionContext.CurrentObjectChanged)
{
if (_previousModel != null && _previousModel != View.Model)
{
View.SetModel(_previousModel);
info.Rule.View = _previousModel;
}
}
}
}
public override void ExecuteRule(LogicRuleInfo <IActionStateRule> logicRuleInfo,
ExecutionContext executionContext)
{
IActionStateRule rule = logicRuleInfo.Rule;
foreach (ActionBase actionBase in GetActions(rule))
{
switch (rule.ActionState)
{
case ActionState.Hidden:
ActivateDeActivateAction(logicRuleInfo, actionBase);
break;
case ActionState.Disabled:
EnableDisableAction(logicRuleInfo, actionBase);
break;
case ActionState.Executed: {
if (logicRuleInfo.Active)
{
ExecuteAction(actionBase);
}
}
break;
case ActionState.ExecutedAndDisable:
ExecuteAndDisableAction(actionBase);
break;
}
}
}
protected override object AddControl(object viewSiteControl, object control, LogicRuleInfo<IAdditionalViewControlsRule> info, AdditionalViewControlsProviderCalculator calculator, ExecutionContext context) {
var value = (Control)control;
value.Dock = info.Rule.AdditionalViewControlsProviderPosition == AdditionalViewControlsProviderPosition.Bottom ? DockStyle.Bottom : DockStyle.Top;
Control.ControlCollection collection = ((Control)viewSiteControl).Controls;
var getControl = (Control) GetControl(collection, control, calculator, info);
collection.Add(getControl);
return getControl;
}
protected override LogicRuleInfo <TConditionalLogicRule> CalculateLogicRuleInfo(object targetObject, TConditionalLogicRule logicRule, ActionBase action)
{
LogicRuleInfo <TConditionalLogicRule> calculateLogicRuleInfo = base.CalculateLogicRuleInfo(targetObject, logicRule, action);
ConditionalLogicRuleManager <TConditionalLogicRule> .CalculateLogicRuleInfo(calculateLogicRuleInfo);
return(calculateLogicRuleInfo);
}
void ProcessActions(LogicRuleInfo info, IObjectViewRule objectViewRule)
{
var createdView = ((ActionBaseEventArgs)info.EventArgs).ShowViewParameters.CreatedView;
if (createdView.Model.GetType() == objectViewRule.ObjectView.GetType())
{
createdView.SetModel(objectViewRule.ObjectView);
}
}
protected override object AddControl(object viewSiteControl, object control, LogicRuleInfo<IAdditionalViewControlsRule> additionalViewControlsRule, AdditionalViewControlsProviderCalculator calculator, ExecutionContext context) {
ControlCollection collection = ((Control)viewSiteControl).Controls;
object o = GetControl(collection, control, calculator, additionalViewControlsRule);
((Control) o).Visible = true;
if (additionalViewControlsRule.Rule.AdditionalViewControlsProviderPosition == AdditionalViewControlsProviderPosition.Top)
collection.AddAt(0, (Control)o);
else
collection.Add((Control)o);
return o;
}
void CustomProcessSelectedItem(LogicRuleInfo info, IObjectViewRule objectViewRule)
{
var customProcessListViewSelectedItemEventArgs = ((CustomProcessListViewSelectedItemEventArgs)info.EventArgs);
var type = objectViewRule.ObjectView.ModelClass.TypeInfo.Type;
var collectionSource = Application.CreateCollectionSource(Application.CreateObjectSpace(type), type, objectViewRule.ObjectView.Id);
var showViewParameters = customProcessListViewSelectedItemEventArgs.InnerArgs.ShowViewParameters;
showViewParameters.CreatedView = Application.CreateListView((IModelListView)objectViewRule.ObjectView, collectionSource, true);
customProcessListViewSelectedItemEventArgs.Handled = true;
}
public override void ExecuteRule(LogicRuleInfo <IControllerStateRule> info, ExecutionContext executionContext)
{
if (!string.IsNullOrEmpty(info.Rule.Module))
{
ChangeStateOnModules(info);
}
else
{
ChangeState(info);
}
}
bool GetScedulerState(LogicRuleInfo logicRuleInfo)
{
IScheduler scheduler = Application.FindModule <JobSchedulerModule>().Scheduler;
if (scheduler != null)
{
logicRuleInfo.Active = !scheduler.IsStarted;
return(!logicRuleInfo.Active);
}
return(false);
}
void EnableDisableAction(LogicRuleInfo info, ActionBase actionBase)
{
if (info.InvertCustomization)
{
actionBase.Enabled[ActiveObjectTypeHasActionRules] = true;
}
else
{
actionBase.Enabled[ActiveObjectTypeHasActionRules] = !info.Active && !info.InvertCustomization;
}
}
void ActivateDeActivateAction(LogicRuleInfo info, ActionBase actionBase)
{
if (info.InvertCustomization)
{
actionBase.Active[ActiveObjectTypeHasActionRules] = true;
}
else
{
actionBase.Active[ActiveObjectTypeHasActionRules] = !info.Active;
}
}
void ChangeStateOnModules(LogicRuleInfo info)
{
var controllerStateRule = ((IControllerStateRule)info.Rule);
IEnumerable <string> assemblies = GetAssemblies(controllerStateRule);
var controllers = GetControllers(assemblies);
foreach (Controller controller in controllers)
{
controller.Active[ActiveObjectTypeHasControllerRules] = !info.Active;
}
}
protected virtual void InitializeControl(object control, LogicRuleInfo <IAdditionalViewControlsRule> additionalViewControlsRule, AdditionalViewControlsProviderCalculator calculator, ExecutionContext context)
{
if (control is ISupportAppeareance)
{
var supportAppeareance = ((ISupportAppeareance)control);
supportAppeareance.BackColor = additionalViewControlsRule.Rule.BackColor;
supportAppeareance.Height = additionalViewControlsRule.Rule.Height;
supportAppeareance.ForeColor = additionalViewControlsRule.Rule.ForeColor;
supportAppeareance.FontStyle = additionalViewControlsRule.Rule.FontStyle;
supportAppeareance.FontSize = additionalViewControlsRule.Rule.FontSize;
}
}
void CustomProcessSelectedItem(LogicRuleInfo info, IObjectViewRule objectViewRule)
{
var customProcessListViewSelectedItemEventArgs = ((CustomProcessListViewSelectedItemEventArgs)info.EventArgs);
var showViewParameters = customProcessListViewSelectedItemEventArgs.InnerArgs.ShowViewParameters;
showViewParameters.CreatedView = Application.CreateView(objectViewRule.ObjectView);
if (showViewParameters.CreatedView is DetailView)
{
showViewParameters.CreatedView.CurrentObject = showViewParameters.CreatedView.ObjectSpace.GetObject(View.CurrentObject);
}
customProcessListViewSelectedItemEventArgs.Handled = true;
}
public override void ExecuteRule(LogicRuleInfo <IMasterDetailRule> info, ExecutionContext executionContext)
{
if (info.Active)
{
if (!(_masterDetailRules.Contains(info.Rule)))
{
_masterDetailRules.Add(info.Rule);
}
}
else
{
_masterDetailRules.Remove(info.Rule);
}
}
void LogicRuleViewControllerOnLogicRuleExecute(object sender, LogicRuleExecuteEventArgs e)
{
LogicRuleInfo info = e.LogicRuleInfo;
if (info.InvertCustomization)
{
return;
}
var objectViewRule = info.Rule as IObjectViewRule;
if (objectViewRule != null)
{
ExecutionContext executionContext = e.ExecutionContext;
switch (executionContext)
{
case ExecutionContext.None:
if (info.Active)
{
ProcessActions(info, objectViewRule);
}
break;
case ExecutionContext.CustomProcessSelectedItem:
if (info.Active && objectViewRule.ObjectView is IModelListView)
{
CustomProcessSelectedItem(info, objectViewRule);
}
break;
case ExecutionContext.CustomizeShowViewParameters:
if (info.Active && objectViewRule.ObjectView is IModelDetailView)
{
CustomizeShowViewParameters(info, objectViewRule);
}
break;
case ExecutionContext.CurrentObjectChanged:
if (View.Model.AsObjectView is IModelDetailView && objectViewRule.ObjectView is IModelDetailView && View.ObjectTypeInfo != null)
{
var modelView = info.Active ? objectViewRule.ObjectView : GetDefaultObjectView();
if (modelView != null)
{
Frame.GetController <ModelController>().SetView();
}
}
break;
}
}
}
void CustomizeShowViewParameters(LogicRuleInfo info, IObjectViewRule objectViewRule)
{
var customizeShowViewParametersEventArgs = ((CustomizeShowViewParametersEventArgs)info.EventArgs);
var createdView = customizeShowViewParametersEventArgs.ShowViewParameters.CreatedView;
if (createdView is DetailView)
{
_defaultObjectView = createdView.Model;
customizeShowViewParametersEventArgs.ShowViewParameters.Controllers.Add(new InfoController(true)
{
Model = _defaultObjectView
});
createdView.SetModel(objectViewRule.ObjectView);
}
}
EmailTemplateEngine.Email CreateEmail(LogicRuleInfo logicRuleInfo, EmailRule emailRule, IModelSmtpClientContext modelSmtpClientContext, IEmailTemplate emailTemplateObject, IModelApplicationEmail modelApplicationEmail)
{
var templateEngine = new EmailTemplateEngine.EmailTemplateEngine(emailTemplateObject);
var email = templateEngine.Execute(logicRuleInfo.Object, emailRule.ID);
if (emailRule.CurrentObjectEmailMember != null)
{
var toEmail = emailRule.CurrentObjectEmailMember.MemberInfo.GetValue(logicRuleInfo.Object) as string;
email.To.Add(toEmail);
}
if (!string.IsNullOrEmpty(emailRule.EmailReceipientsContext))
{
AddReceipients(emailRule, modelApplicationEmail, email, logicRuleInfo.Object);
}
email.From = modelSmtpClientContext.SenderEmail;
modelSmtpClientContext.ReplyToEmails.Split(';').Each(s => email.ReplyTo.Add(s));
return(email.To.Count == 0 ? null : email);
}
protected void ChangeState(LogicRuleInfo info)
{
var rule = ((IControllerStateRule)info.Rule);
Frame.GetController(rule.ControllerType, controller => {
if (rule.ControllerState == Persistent.Base.ModelArtifact.ControllerState.Register)
{
if (!controller.Active)
{
Frame.RegisterController(controller);
}
}
else
{
controller.Active[ActiveObjectTypeHasControllerRules] = info.InvertCustomization || ((IControllerStateRule)info.Rule).ControllerState == Persistent.Base.ModelArtifact.ControllerState.Enabled;
}
});
}
protected virtual MailMessage CreateEmail(LogicRuleInfo logicRuleInfo, EmailRule emailRule, IModelSmtpClientContext modelSmtpClientContext, IEmailTemplate emailTemplateObject, IModelApplicationEmail modelApplicationEmail)
{
var body = RazorEngineService.RunCompile(emailTemplateObject.Body, Guid.NewGuid().ToString(), null, logicRuleInfo.Object);
var email = new MailMessage {
IsBodyHtml = true,
Subject = RazorEngineService.RunCompile(emailTemplateObject.Subject, Guid.NewGuid().ToString(), null, logicRuleInfo.Object),
Body = body
};
var toEmail = emailRule.CurrentObjectEmailMember?.MemberInfo.GetValue(logicRuleInfo.Object) as string;
toEmail?.Split(';').Each(s => email.To.Add(s));
if (!string.IsNullOrEmpty(emailRule.EmailReceipientsContext))
{
AddReceipients(emailRule, modelApplicationEmail, email, logicRuleInfo.Object);
}
email.From = new MailAddress(modelSmtpClientContext.SenderEmail);
modelSmtpClientContext.ReplyToEmails.Split(';').Each(s => email.ReplyToList.Add(s));
return(email.To.Count == 0 ? null : email);
}
void LogicRuleViewControllerOnLogicRuleExecute(object sender, LogicRuleExecuteEventArgs e)
{
LogicRuleInfo info = e.LogicRuleInfo;
if (info.InvertCustomization)
{
return;
}
var objectViewRule = info.Rule as IObjectViewRule;
if (objectViewRule != null)
{
ExecutionContext executionContext = e.ExecutionContext;
switch (executionContext)
{
case ExecutionContext.None:
if (info.Active)
{
ProcessActions(info, objectViewRule);
}
break;
case ExecutionContext.CustomProcessSelectedItem:
if (info.Active)
{
CustomProcessSelectedItem(info, objectViewRule);
}
break;
case ExecutionContext.CurrentObjectChanged:
if (View.Model.AsObjectView is IModelDetailView && objectViewRule.ObjectView is IModelDetailView && View.ObjectTypeInfo != null)
{
var modelView = info.Active ? objectViewRule.ObjectView : Application.Model.BOModel.GetClass(View.ObjectTypeInfo.Type).DefaultDetailView;
if (modelView != null)
{
var shortcut = new ViewShortcut(modelView.Id, View.ObjectTypeInfo.KeyMember.GetValue(View.CurrentObject).ToString());
Frame.SetView(Application.ProcessShortcut(shortcut), View.Tag as Frame);
}
}
break;
}
}
}
protected override void AddControl(object control, object controls, LogicRuleInfo <IAdditionalViewControlsRule> info)
{
base.AddControl(control, controls, info);
if (info.Rule.Position != Position.DetailViewItem)
{
var supportAdditionalViewControls = Frame.Template as ISupportAdditionalViewControls;
if (supportAdditionalViewControls != null)
{
var asPxCallbackPanel = supportAdditionalViewControls.TopPanel;
if (info.Rule.Position == Position.Bottom)
{
asPxCallbackPanel = supportAdditionalViewControls.BottomPanel;
}
var control1 = ((Control)control);
control1.Visible = info.Active;
asPxCallbackPanel.Controls.Add(control1);
ModifyClientEvent(supportAdditionalViewControls.AsPxGlobalEvents, info);
}
}
}
protected override void InitializeControl(object control, LogicRuleInfo <IAdditionalViewControlsRule> logicRuleInfo,
AdditionalViewControlsProviderCalculator additionalViewControlsProviderCalculator,
ExecutionContext executionContext)
{
base.InitializeControl(control, logicRuleInfo, additionalViewControlsProviderCalculator, executionContext);
var value = (Control)control;
if (logicRuleInfo.Rule.Position != Position.DetailViewItem)
{
if (logicRuleInfo.Rule.Position == Position.Bottom)
{
value.Dock = DockStyle.Bottom;
}
else if (logicRuleInfo.Rule.Position == Position.Top)
{
value.Dock = DockStyle.Top;
}
}
else
{
value.Dock = DockStyle.Fill;
}
}
protected virtual void AddControl(object control, object controls, LogicRuleInfo info)
{
controls.CallMethod("Add", new[] { GetControlType() }, control);
}
protected void ChangeState(LogicRuleInfo <IControllerStateRule> info)
{
Frame.GetController(info.Rule.ControllerType).Active[ActiveObjectTypeHasRules] = info.Rule.ControllerState == ControllerState.Enabled;
}
void ActivateDeActivateAction(LogicRuleInfo info, ActionBase actionBase)
{
actionBase.Active[ActiveObjectTypeHasActionRules] = info.InvertCustomization || ((IActionStateRule)info.Rule).ActionState != Persistent.Base.ModelArtifact.ActionState.Hidden;
}
void EnableDisableAction(LogicRuleInfo info, ActionBase actionBase)
{
actionBase.Enabled[ActiveObjectTypeHasActionRules] = info.InvertCustomization || ((IActionStateRule)info.Rule).ActionState != Persistent.Base.ModelArtifact.ActionState.Disabled;
}
void ActivateDeActivateAction(LogicRuleInfo <IActionStateRule> info, ActionBase actionBase)
{
actionBase.Active[ActiveObjectTypeHasRules] = !info.Active;
}
void ModifyClientEvent(ASPxGlobalEvents asPxGlobalEvents, LogicRuleInfo <IAdditionalViewControlsRule> info)
{
asPxGlobalEvents.ClientSideEvents.EndCallback = info.Active
? "function(s, e) { DXUpdateSplitterSize();DXMoveFooter(); if(s != TopCallBackPanel&&s != BottomCallBackPanel) {TopCallBackPanel.PerformCallback();BottomCallBackPanel.PerformCallback();}; }"
: "function(s, e) { DXUpdateSplitterSize();DXMoveFooter(); }";
}
void EnableDisableAction(LogicRuleInfo <IActionStateRule> info, ActionBase actionBase)
{
actionBase.Enabled[ActiveObjectTypeHasRules] = !info.Active;
}
