public void InitializeProperties(IEntityExtensions entityExtensions)
{
foreach (var propertyInitializer in PropertyInitializers)
{
propertyInitializer((T)entityExtensions.Target);
}
}
public static AuthDB Load(string path)
{
try {
logger.Trace($"Loading AuthDB '{path}'.");
var auth = IEntityExtensions.Deserialize <AuthDB>(path);
for (var i = auth.Imports.Length - 1; i >= 0; --i)
{
var impPath = auth.Imports[i].GetRootedPath(Path.GetDirectoryName(path));
var other = Load(impPath);
auth.Merge(other);
}
return(auth);
}
catch (Exception ex) {
if (!(ex is ValidationException vex))
{
logger.Debug(ex, $"Error loading AuthBD '{path}'");
vex = new ValidationException($"{ex.Message}", ex);
}
vex.Parents.Add(path);
throw vex;
}
}
public static void ApplyPrototype(this IEntityExtensions extensions,
IEntityExtensions prototype)
{
foreach (var rule in prototype.Rules)
{
extensions.AddRuleFromPrototype(rule);
}
extensions.DynamicProperties.AllowDynamicProperties = prototype.DynamicProperties.AllowDynamicProperties;
foreach (var p in prototype.DynamicProperties.PropertiesMetadata
.Where(x => !x.SaveTypeInfo))
{
extensions.DynamicProperties.PropertiesMetadata.Add(new DynamicPropertyMetadata(p.Name, p.Type));
}
if (prototype.IsDirtyTrackingStarted)
{
extensions.StartDirtyTracking();
}
if (prototype.RuleInitialized)
{
extensions.InitializeRules();
}
}
public static BusinessRule <T, V> CreateBusinessRule <T, V>(this IEntityExtensions <T> extension, Expression <Func <T, V> > func, Expression <Func <T, V> > target)
{
var factory = new RuleFactory <T>();
var rule = factory.CreateBusinessRule(func, target);
extension.Rules.Add(rule);
return(rule);
}
public static ActionRule <T> CreateActionRuleWithoutDependency <T>(this IEntityExtensions <T> extension, Action <T> action)
{
var factory = new RuleFactory <T>();
var rule = factory.CreateActionRuleWithoutDependency(action);
extension.Rules.Add(rule);
return(rule);
}
public static ActionRule <T> CreateActionRule <T>(this IEntityExtensions <T> extension, Expression <Action <T> > action)
{
var factory = new RuleFactory <T>();
var rule = factory.CreateActionRule(action);
extension.Rules.Add(rule);
return(rule);
}
public static ValidationRule <T> CreateValidationRule <T>(this IEntityExtensions <T> extension, Expression <Func <T, bool> > predicate)
{
var factory = new RuleFactory <T>();
var rule = factory.CreateValidationRule(predicate);
extension.Rules.Add(rule);
return(rule);
}
public static ValidationRule <T> CreateValidationRuleWithoutDependency <T>(this IEntityExtensions <T> extension, Func <T, bool> predicate)
{
var factory = new RuleFactory <T>();
var rule = factory.CreateValidationRuleWithoutDependency(predicate);
extension.Rules.Add(rule);
return(rule);
}
public static T AddRuleFromPrototype <T>(this IEntityExtensions extension, T rule)
where T : Rule
{
var copy = (T)rule.Copy();
extension.Rules.Add(copy);
return(copy);
}
public IEntityExtensions GetGraphParent(IEntityExtensions extensions)
{
while (extensions.Parent != null)
{
extensions = extensions.Parent;
}
return(extensions);
}
public static BusinessRule <T, V> CreateBusinessRuleWithoutDependency <T, V>(this IEntityExtensions <T> extensions,
Func <T, V> func, Func <T, V> getTarget, Action <T, V> setTarget)
{
var factory = new RuleFactory <T>();
var rule = factory.CreateBusinessRuleWithoutDependency(func, getTarget, setTarget);
extensions.Rules.Add(rule);
return(rule);
}
public static SwitchRule <T, S> CreateSwitchableRule <T, S>(this IEntityExtensions <T> extensions,
Expression <Func <T, S> > selector, bool reevaluate)
{
var factory = new RuleFactory <T>();
var rule = factory.CreateSwitchableRule(selector, reevaluate);
extensions.Rules.Add(rule);
return(rule);
}
public static ValidationRule <T> CreateConfirmPasswordRule <T>(this IEntityExtensions <T> extension, Expression <Func <T, string> > passwordSelector,
Expression <Func <T, string> > confirmPasswordSelector)
{
var password = passwordSelector.Compile();
var confirm = confirmPasswordSelector.Compile();
var rule = extension.CreateValidationRule(p => password(p) == confirm(p) || string.IsNullOrEmpty(confirm(p)))
.WithOwner(confirmPasswordSelector);
return(rule);
}
public static ValidationRule <T> CreateValidationRule <T>(this IEntityExtensions <T> extension, string formula)
{
var factory = new RuleFactory <T>();
factory.Compiler = CreateCompiler(extension);
var rule = factory.CreateValidationRule(formula);
extension.Rules.Add(rule);
return(rule);
}
public static BrokenRuleToken Create(IEntityExtensions extension,
params BrokenRule[] brokenRules)
{
var token = new BrokenRuleToken
{
BrokenRules = brokenRules,
Extension = extension
};
token.Add();
return(token);
}
public void InitializeRules(IEntityExtensions entityExtensions)
{
foreach (var ruleInitializer in RuleInitializers)
{
ruleInitializer((T)entityExtensions.Target);
}
foreach (var rulePrototype in RulePrototypes)
{
entityExtensions.AddRuleFromPrototype(rulePrototype).Start();
}
}
public static EntityExtensions GetImplementation(this IEntityExtensions extensions)
{
if (extensions is EntityExtensions)
{
return((EntityExtensions)extensions);
}
if (extensions is IGetInternalEntityExtensions)
{
return(((IGetInternalEntityExtensions)extensions).GetExtensions().GetImplementation());
}
throw new InvalidOperationException();
}
private static FormulaCompiler CreateCompiler(IEntityExtensions extensions)
{
Type thisType = extensions.Target.GetType();
var compiler = new FormulaCompiler();
compiler.With(new TypeCallProvider(thisType));
compiler.WithDynamicEntity(thisType, extensions.DynamicProperties.AllowDynamicProperties,
extensions.DynamicProperties.PropertiesMetadata);
return(compiler);
}
public static IEntityExtensions <T> GetTypeSafe <T>(this IEntityExtensions extensions)
{
if (!(extensions.Target is T))
{
throw new InvalidOperationException(string.Format("Type {0} cannot be casted to {1}.", extensions.Target.GetType(), typeof(T)));
}
if (extensions is IGetInternalEntityExtensions)
{
extensions = ((IGetInternalEntityExtensions)extensions).GetExtensions();
}
return(new EntityExtensions <T>(extensions));
}
public static void EnableByTag(this IEntityExtensions extensions, object tag, bool enable)
{
foreach (var rule in extensions.Rules.Where(r => r.Tag != null && r.Tag.Equals(tag)))
{
if (enable)
{
rule.Enable();
}
else
{
rule.Disable();
}
}
}
private SwitchRule FindSwitch(IEntityExtensions extensions)
{
var rule = extensions.Rules.OfType <SwitchRule>().FirstOrDefault(r => r.SwitchType == Switch.GetType());
if (rule != null)
{
return(rule);
}
if (extensions.Parent != null)
{
return(FindSwitch(extensions.Parent));
}
return(null);
}
internal static void CheckParentChanged(object target, IEntityExtensions oldParent, IEntityExtensions newParent)
{
if (ParentChangeWarning == RuleDebuggerEntrySeverity.None)
{
return;
}
if (oldParent != null && newParent != null && oldParent != newParent)
{
var message =
string.Format("Parent of entity {0} was changed from {1} to {2}, possible buggy behaviour.",
target, oldParent, newParent);
CheckInternal(ParentChangeWarning, message);
}
}
public static void SwitchRulesByTag(this IEntityExtensions extensions, object tag)
{
extensions.GetImplementation().SafeRecursiveAction(e =>
{
foreach (var rule in e.Rules.Where(r => r.Tag != null && r.Tag.GetType() == tag.GetType()))
{
if (rule.Tag.Equals(tag) && rule.State == RuleState.Disabled)
{
rule.Enable();
}
else if (!rule.Tag.Equals(tag) && rule.State == RuleState.Enabled)
{
rule.Disable();
}
}
});
}
public static void ReevaluateRulesByTag(this IEntityExtensions extensions, object tag)
{
extensions.GetImplementation().SafeRecursiveAction(e =>
{
foreach (var rule in e.Rules.Where(r => r.Tag != null && r.Tag.Equals(tag)))
{
if (rule is ActionRule)
{
((ActionRule)rule).Invoke();
}
else if (rule is BusinessRule)
{
((BusinessRule)rule).Evaluate();
}
}
});
}
public static Session Load(string path)
{
try {
logger.Trace($"Loading Session '{path}'.");
var session = IEntityExtensions.Deserialize <Session>(path);
return(session);
}
catch (Exception ex) {
if (!(ex is ValidationException vex))
{
logger.Debug(ex, $"Error loading Session '{path}'");
vex = new ValidationException($"{ex.Message}", ex);
}
vex.Parents.Add(path);
throw vex;
}
}
protected IEntityExtensions GetProperty(object target, Func <object, object> propertySelector)
{
IEntityExtensions extensions = null;
try
{
var propertyValue = propertySelector(target);
extensions = GetIEntityExtensionsFromObject(propertyValue);
}
catch (Exception e)
{
if (ExceptionHelper.IsNonrecoverableException(e))
{
throw;
}
}
return(extensions);
}
public void XXX()
{
var eb = new A();
eb.Extensions.CreateValidationRule(o => false)
.Start();
var ebg = new B();
ebg.Extensions.CreateValidationRule(o => o.Number == 4)
.Start();
IEntityExtensions e = eb.Extensions;
IEntityExtensions e2 = ebg.Extensions;
IEntityExtensions <B> e3 = ebg.Extensions;
IEntityBase b = eb;
IEntityBase b2 = ebg;
IEntityBase <B> b3 = ebg;
}
public static SwitchRule <T, S> CreateSwitchableRule <T, S>(this IEntityExtensions <T> extensions, Expression <Func <T, S> > selector)
{
return(CreateSwitchableRule(extensions, selector, true));
}
public static void EnableByTag(this IEntityExtensions extensions, object tag)
{
EnableByTag(extensions, tag, true);
}
public static IEntityExtensions AddProperty <TValue>(this IEntityExtensions extension, string name, DynamicPropertyMetadataOptions options)
{
return(AddProperty(extension, name, typeof(TValue), options));
}
