public HeaderSourceUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
_dateTimeProps = new FieldUpdateProperties <MessageHeaderSource, DateTime>(
yearUpdateConfiguration.ShouldUpdateDate(typeof(MessageHeaderSource).Name, "DateTime"),
s => s.DateTime,
ruleProvider.BuildStandardDateUplifter <DateTime>().Definition);
}
public LearnerUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
_dateOfBirthProps = new FieldUpdateProperties <MessageLearner, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(typeof(MessageLearner).Name, "DateOfBirth"),
s => s.DateOfBirth,
ruleProvider.BuildStandardDateUplifter <DateTime?>().Definition);
}
public HeaderCollectionDetailsUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
_filePreparationDateProps = new FieldUpdateProperties <MessageHeaderCollectionDetails, DateTime>(
yearUpdateConfiguration.ShouldUpdateDate(typeof(MessageHeaderCollectionDetails).Name, "FilePreparationDate"),
s => s.FilePreparationDate,
ruleProvider.BuildStandardDateUplifter <DateTime>().Definition);
}
public LearnerLearningDeliveryAppFinRecordUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
_aFinDateProps = new FieldUpdateProperties <MessageLearnerLearningDeliveryAppFinRecord, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(typeof(MessageLearnerLearningDeliveryAppFinRecord).Name, "AFinDate"),
s => s.AFinDate,
ruleProvider.BuildStandardDateUplifter <DateTime?>().Definition);
}
public ViewModelFactory(SummaryDatabase summaryDatabase)
{
this.summaryDatabase = summaryDatabase;
accountRuleProvider = new RuleProvider(new RuleFactory <Account>(summaryDatabase.AccountProvider));
expenseRuleProvider = new RuleProvider(new RuleFactory <Expense>(summaryDatabase.ExpenseProvider));
}
public LearnerAmalgamator(
IAmalgamator <MessageLearnerProviderSpecLearnerMonitoring> providerSpecLearnerMonitoringAmalgamator,
IAmalgamator <MessageLearnerLearnerEmploymentStatus> learnerEmploymentStatusAmalgamator,
IAmalgamator <MessageLearnerLearnerHE> learnerHEAmalgamator,
IRuleProvider ruleProvider,
IAmalgamationErrorHandler amalgamationErrorHandler)
: base(Entity.Learner, (x) => x.LearnRefNumber, amalgamationErrorHandler)
{
_providerSpecLearnerMonitoringAmalgamator = providerSpecLearnerMonitoringAmalgamator;
_learnerEmploymentStatusAmalgamator = learnerEmploymentStatusAmalgamator;
_learnerHEAmalgamator = learnerHEAmalgamator;
_standardRuleString = ruleProvider.BuildStandardRule <string>();
_standardRuleStringFirstItem = ruleProvider.BuildStandardRuleFirstItem <string>();
_standardRuleLong = ruleProvider.BuildStandardRule <long?>();
_standardRuleDateTime = ruleProvider.BuildStandardRule <DateTime?>();
_addressRule = ruleProvider.BuildAddressRule();
_ulnRule = ruleProvider.BuildUlnRule();
_alsCostrule = ruleProvider.BuildAlsCostRule();
_postCodeRule = ruleProvider.BuildPostCodeRule();
_learnerContactPreferenceCollectionRule = ruleProvider.BuildLearnerContactPreferenceCollectionRule();
_lLDDandHealthProblemCollectionRule = ruleProvider.BuildLLDDandHealthProblemCollectionRule();
_learnerFAMAmalgamationRule = ruleProvider.BuildLearnerFAMAmalgamationRule();
_learningDeliveryRule = ruleProvider.BuildLearningDeliveryRule();
}
public LearnerLearningDeliveryUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
var modelName = typeof(MessageLearnerLearningDelivery).Name;
Func <DateTime?, DateTime?> standardNullableDateUplifter = ruleProvider.BuildStandardDateUplifter <DateTime?>().Definition;
_learnStartDateProps = new FieldUpdateProperties <MessageLearnerLearningDelivery, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "LearnStartDate"),
s => s.LearnStartDate,
standardNullableDateUplifter);
_origLearnStartDateProps = new FieldUpdateProperties <MessageLearnerLearningDelivery, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "OrigLearnStartDate"),
s => s.OrigLearnStartDate,
standardNullableDateUplifter);
_learnPlanEndDateProps = new FieldUpdateProperties <MessageLearnerLearningDelivery, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "LearnPlanEndDate"),
s => s.LearnPlanEndDate,
standardNullableDateUplifter);
_learnActEndDateProps = new FieldUpdateProperties <MessageLearnerLearningDelivery, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "LearnActEndDate"),
s => s.LearnActEndDate,
standardNullableDateUplifter);
_achDateProps = new FieldUpdateProperties <MessageLearnerLearningDelivery, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "AchDate"),
s => s.AchDate,
standardNullableDateUplifter);
}
public LearnerLearnerEmploymentStatusUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
_dateEmpStatAppProps = new FieldUpdateProperties <MessageLearnerLearnerEmploymentStatus, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(typeof(MessageLearnerLearnerEmploymentStatus).Name, "DateEmpStatApp"),
s => s.DateEmpStatApp,
ruleProvider.BuildStandardDateUplifter <DateTime?>().Definition);
}
/// <summary>
/// Debug helper to dump the entire extension graph
/// </summary>
public void DebugDumpGraph(TextWriter output)
{
var providers = this._root;
IRuleProvider root = (IRuleProvider)providers;
DumpRule(root, output);
}
public SubscribeToContentServicePublishedComponent(ILogger logger, IContentService cs, IContentTypeService cts)
{
_logger = logger;
_cs = cs;
_cts = cts;
_rp = new ConfigFileRuleProvider(_logger);
_autoNode = new AutoNode(_logger, _cs, _cts, _rp);
}
public void Init() {
var builder = new ContainerBuilder();
builder.RegisterType<UrlRuleProvider>().As<IRuleProvider>();
_stubContextAccessor = new StubHttpContextAccessor();
builder.RegisterInstance(_stubContextAccessor).As<IHttpContextAccessor>();
_container = builder.Build();
_urlRuleProvider = _container.Resolve<IRuleProvider>();
}
public LLDDandHealthProblemAmalgamator NewAmalgamator(
IRuleProvider ruleProvider = null,
IAmalgamationErrorHandler amalgamationErrorHandler = null)
{
return(new LLDDandHealthProblemAmalgamator(
ruleProvider ?? Mock.Of <IRuleProvider>(),
amalgamationErrorHandler ?? Mock.Of <IAmalgamationErrorHandler>()));
}
public AutoNode(ILogger logger, IContentService cs, IContentTypeService cts, IRuleProvider rp = null)
{
_rules = new List <AutoNodeRule>();
_rulesLoaded = false;
_logger = logger;
_cs = cs;
_cts = cts;
_rp = rp;
}
public RuleRunner(IRuleProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
_provider = provider;
}
public void Init() {
var builder = new ContainerBuilder();
_shellSettings = new ShellSettings {RequestUrlPrefix = string.Empty};
builder.RegisterType<UrlRuleProvider>().As<IRuleProvider>();
builder.RegisterInstance(_shellSettings);
_stubContextAccessor = new StubHttpContextAccessor();
builder.RegisterInstance(_stubContextAccessor).As<IHttpContextAccessor>();
_container = builder.Build();
_urlRuleProvider = _container.Resolve<IRuleProvider>();
}
public TagEngine(IHarborClient harbor, ApplicationSettings settings, Serilog.ILogger log, IRuleProvider rules, IResultNotifier notifications)
{
_harbor = harbor ?? throw new ArgumentNullException(nameof(harbor));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
Log = log ?? throw new ArgumentNullException(nameof(log));
_ruleProvider = rules ?? throw new ArgumentNullException(nameof(rules));
_notification = notifications;
_destructive = !_settings.Nondestructive;
}
public void Init()
{
var builder = new ContainerBuilder();
builder.RegisterType <UrlRuleProvider>().As <IRuleProvider>();
_stubContextAccessor = new StubHttpContextAccessor();
builder.RegisterInstance(_stubContextAccessor).As <IHttpContextAccessor>();
_container = builder.Build();
_urlRuleProvider = _container.Resolve <IRuleProvider>();
}
public void Init() {
var builder = new ContainerBuilder();
_shellSettings = new ShellSettings {RequestUrlPrefix = string.Empty};
builder.RegisterType<UrlRuleProvider>().As<IRuleProvider>();
builder.RegisterInstance(_shellSettings);
_stubContextAccessor = new StubHttpContextAccessor();
builder.RegisterInstance(_stubContextAccessor).As<IHttpContextAccessor>();
_container = builder.Build();
_urlRuleProvider = _container.Resolve<IRuleProvider>();
}
/// <summary>
/// Adds a rule provider.
/// </summary>
/// <param name="ruleProvider">A rule provider.</param>
/// <returns>A rule provider builder that now also builds rules from <paramref name="ruleProvider"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="ruleProvider"/> is <c>null</c>.</exception>
public IRuleProviderBuilder AddRuleProvider(IRuleProvider ruleProvider)
{
if (ruleProvider == null)
{
throw new ArgumentNullException(nameof(ruleProvider));
}
var ruleProviders = _ruleProviders.Append(ruleProvider).ToList();
return(new RuleProviderBuilder(ruleProviders));
}
public LearnerAmalgamator BuildAmalgamator(
IAmalgamator <MessageLearnerLearnerEmploymentStatus> learnerEmploymentStatusAmalgamator = null,
IAmalgamator <MessageLearnerLearnerHE> learnerHEAmalgamator = null,
IRuleProvider ruleProvider = null,
IAmalgamationErrorHandler amalgamationErrorHandler = null)
{
return(null);
//new LearnerAmalgamator(
//learnerEmploymentStatusAmalgamator ?? Mock.Of<IAmalgamator<MessageLearnerLearnerEmploymentStatus>>(),
//learnerHEAmalgamator ?? Mock.Of<IAmalgamator<MessageLearnerLearnerHE>>(),
//ruleProvider ?? Mock.Of<IRuleProvider>(),
//amalgamationErrorHandler ?? Mock.Of<IAmalgamationErrorHandler>());
}
public IEnumerable <Rule> GetRules()
{
var filter = _description;
IRuleProvider inner = _inner as IRuleProvider;
if (inner != null)
{
foreach (var rule in inner.GetRules())
{
rule.Filter = filter;
yield return(rule);
}
}
}
public SourceFilesSourceFileUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
var modelName = typeof(MessageSourceFilesSourceFile).Name;
_filePreparationDateProps = new FieldUpdateProperties <MessageSourceFilesSourceFile, DateTime>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "FilePreparationDate"),
s => s.FilePreparationDate,
ruleProvider.BuildStandardDateUplifter <DateTime>().Definition);
_dateTimeProps = new FieldUpdateProperties <MessageSourceFilesSourceFile, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "DateTime"),
s => s.DateTime,
ruleProvider.BuildStandardDateUplifter <DateTime?>().Definition);
}
public LearnerLearningDeliveryLearningDeliveryFAMUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
var modelName = typeof(MessageLearnerLearningDeliveryLearningDeliveryFAM).Name;
Func <DateTime?, DateTime?> standardNullableDateUplifter = ruleProvider.BuildStandardDateUplifter <DateTime?>().Definition;
_learnDelFAMDateFromProps = new FieldUpdateProperties <MessageLearnerLearningDeliveryLearningDeliveryFAM, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "LearnDelFAMDateFrom"),
s => s.LearnDelFAMDateFrom,
standardNullableDateUplifter);
_learnDelFAMDateToProps = new FieldUpdateProperties <MessageLearnerLearningDeliveryLearningDeliveryFAM, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "LearnDelFAMDateTo"),
s => s.LearnDelFAMDateTo,
standardNullableDateUplifter);
}
public LearnerLearningDeliveryLearningDeliveryWorkPlacementUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
var modelName = typeof(MessageLearnerLearningDeliveryLearningDeliveryWorkPlacement).Name;
Func <DateTime?, DateTime?> standardNullableDateUplifter = ruleProvider.BuildStandardDateUplifter <DateTime?>().Definition;
_workPlaceStartDateProps = new FieldUpdateProperties <MessageLearnerLearningDeliveryLearningDeliveryWorkPlacement, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "WorkPlaceStartDate"),
s => s.WorkPlaceStartDate,
standardNullableDateUplifter);
_workPlaceEndDateProps = new FieldUpdateProperties <MessageLearnerLearningDeliveryLearningDeliveryWorkPlacement, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "WorkPlaceEndDate"),
s => s.WorkPlaceEndDate,
standardNullableDateUplifter);
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
/// <param name="deck">
/// The deck to use in this game.
/// </param>
/// <param name="ruleProvider">
/// The rule provider.
/// </param>
public Game(Deck deck, IRuleProvider ruleProvider)
{
if (deck == null)
{
throw new ArgumentNullException("deck");
}
if (ruleProvider == null)
{
throw new ArgumentNullException("ruleProvider");
}
this.players = new List <Player>();
this.deck = deck;
this.deck.Reshuffle += new EventHandler(this.Deck_Reshuffle);
this.ruleProvider = ruleProvider;
}
private static async Task DoClean(ApplicationSettings appSettings, IRuleProvider rules)
{
var engine = new TagEngine(
new HarborClient(NormalizeEndpointUrl(appSettings.Endpoint)),
appSettings,
Log.ForContext <TagEngine>(),
rules,
appSettings.SlackWebhook == null ? null : new SlackResultNotifier(appSettings)
);
var sw = new Stopwatch();
sw.Start();
await engine.Process();
Log.Information("Finished in {elapsed}", sw.Elapsed);
}
public LearnerDestinationandProgressionDPOutcomeUplifter(IRuleProvider ruleProvider, IYearUpdateConfiguration yearUpdateConfiguration)
{
var modelName = typeof(MessageLearnerDestinationandProgressionDPOutcome).Name;
Func <DateTime?, DateTime?> standardNullableDateUplifter = ruleProvider.BuildStandardDateUplifter <DateTime?>().Definition;
_outStartDateProps = new FieldUpdateProperties <MessageLearnerDestinationandProgressionDPOutcome, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "OutStartDate"),
s => s.OutStartDate,
standardNullableDateUplifter);
_outEndDateProps = new FieldUpdateProperties <MessageLearnerDestinationandProgressionDPOutcome, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "OutEndDate"),
s => s.OutEndDate,
standardNullableDateUplifter);
_outCollDateProps = new FieldUpdateProperties <MessageLearnerDestinationandProgressionDPOutcome, DateTime?>(
yearUpdateConfiguration.ShouldUpdateDate(modelName, "OutCollDate"),
s => s.OutCollDate,
standardNullableDateUplifter);
}
// Get a better implementation
public Type GetDefaultType(
Attribute attribute,
FileAccess access, // direction In, Out, In/Out
Type requestedType) // combination of Cardinality and DataType.
{
if (attribute == null)
{
throw new ArgumentNullException(nameof(attribute));
}
if (requestedType == null)
{
requestedType = typeof(object);
}
var providers = this._root;
IRuleProvider root = (IRuleProvider)providers;
var type = root.GetDefaultType(attribute, access, requestedType);
if ((type == null) && (access == FileAccess.Read))
{
// For input bindings, if we have a specific requested type, then return and try to bind against that.
// ITriggerBindingProvider doesn't provide rules.
if (requestedType != typeof(object))
{
return(requestedType);
}
else
{
// common default. If binder doesn't support this, it will fail later in the pipeline.
return(typeof(String));
}
}
if (type == null)
{
throw new InvalidOperationException($"Can't bind {attribute.GetType().Name} to a script-compatible type for {access} access" +
((requestedType != null) ? $"to { requestedType.Name }." : "."));
}
return(type);
}
public AccountViewModel(IDatabaseProvider <Account> accountProvider,
IRuleProvider ruleProvider,
Account account) :
base(ruleProvider)
{
this.accountProvider = accountProvider;
this.account = account;
funds = account.Value;
addFundsCommand = new DelegateCommand(Add, () => CanAdd);
deleteAccountCommand = new DelegateCommand(Delete);
accountProvider.DatabaseChanged += (sender, e) =>
{
if (e.ChangedAction == ChangedAction.Update)
{
if (this.account.Name.Equals(e.DataItem.Name))
{
Funds = e.DataItem.Value;
}
}
};
}
public ExpenseViewModel(IDatabaseProvider <Expense> expenseProvider,
IRuleProvider ruleProvider,
Expense expense) :
base(ruleProvider)
{
this.expense = expense;
this.expenseProvider = expenseProvider;
limit = expense.Value;
setLimitCommand = new DelegateCommand(SetLimitForExpense, () => CanSet);
deleteExpanseCommand = new DelegateCommand(Delete);
expenseProvider.DatabaseChanged += (sender, e) =>
{
if (e.ChangedAction == ChangedAction.Update)
{
if (this.expense.Name.Equals(e.DataItem.Name))
{
Limit = e.DataItem.Value;
}
}
};
}
public ExpensesWindowViewModel(IDatabaseProvider <Expense> expenseProvider,
IRuleProvider ruleProvider,
IViewModelFactory viewModelFactory) :
base(ruleProvider)
{
this.expenseProvider = expenseProvider;
this.viewModelFactory = viewModelFactory;
LoadFromExpenseProvider();
LoadExpenseIcons();
addExpanseCommand = new DelegateCommand(AddExpense, () => CanAdd);
expenseProvider.DatabaseChanged += (sender, e) =>
{
if (e.ChangedAction == ChangedAction.Add)
{
var accountViewModel = viewModelFactory.CreateExpenseViewModel(e.DataItem);
expenseList.Add(accountViewModel);
}
else if (e.ChangedAction == ChangedAction.Remove)
{
foreach (ExpenseViewModel expense in expenseList)
{
if (expense.Name.Equals(e.DataItem.Name))
{
expenseList.Remove(expense);
if (HasErrors)
{
Validate();
}
break;
}
}
}
};
}
public AccountsWindowViewModel(IDatabaseProvider <Account> accountProvider,
IRuleProvider ruleProvider,
IViewModelFactory viewModelFactory) :
base(ruleProvider)
{
this.accountProvider = accountProvider;
this.viewModelFactory = viewModelFactory;
addAccountCommand = new DelegateCommand(AddAccount, () => CanAdd);
LoadFromAccountProvider();
LoadAccountIcons();
accountProvider.DatabaseChanged += (sender, e) =>
{
if (e.ChangedAction == ChangedAction.Add)
{
var accountViewModel = viewModelFactory.CreateAccountViewModel(e.DataItem);
accountList.Add(accountViewModel);
}
else if (e.ChangedAction == ChangedAction.Remove)
{
foreach (AccountViewModel account in accountList)
{
if (account.Name.Equals(e.DataItem.Name))
{
accountList.Remove(account);
if (HasErrors)
{
Validate();
}
break;
}
}
}
};
}
public ViewModelServices(
IRuleProvider ruleProvider,
IObservableRegistrationService observableRegistration,
IValidator validator,
ISchedulers schedulers,
INavigationService navigationService,
IRequestNavigation requestNavigation,
IAsyncCommandBus commandBus,
IAsyncQueryBus queryBus,
ICommandEvents commandEvents,
ICommandStateEvents commandStateEvents,
IQueryStateEvents queryStateEvents)
{
if (ruleProvider == null) throw new ArgumentNullException("ruleProvider");
if (observableRegistration == null) throw new ArgumentNullException("observableRegistration");
if (validator == null) throw new ArgumentNullException("validator");
if (schedulers == null) throw new ArgumentNullException("schedulers");
if (navigationService == null) throw new ArgumentNullException("navigationService");
if (requestNavigation == null) throw new ArgumentNullException("requestNavigation");
if (commandBus == null) throw new ArgumentNullException("commandBus");
if (queryBus == null) throw new ArgumentNullException("queryBus");
if (commandEvents == null) throw new ArgumentNullException("commandEvents");
if (commandStateEvents == null) throw new ArgumentNullException("commandStateEvents");
if (queryStateEvents == null) throw new ArgumentNullException("queryStateEvents");
Schedulers = schedulers;
Validator = validator;
ObservableRegistration = observableRegistration;
RuleProvider = ruleProvider;
CommandStateEvents = commandStateEvents;
QueryStateEvents = queryStateEvents;
CommandEvents = commandEvents;
QueryBus = queryBus;
CommandBus = commandBus;
RequestNavigation = requestNavigation;
NavigationService = navigationService;
}
public RuleManager(IRuleProvider ruleProviders, IEnumerable<IScriptExpressionEvaluator> evaluators) {
_ruleProviders = ruleProviders;
_evaluators = evaluators;
T = NullLocalizer.Instance;
}
public Critic(RuleContext context, Settings settings = null, IRuleProvider ruleProvider = null)
{
Context = context;
Settings = settings ?? new Settings();
RuleProvider = ruleProvider ?? DefaultRuleProvider.Create(Settings);
}
public LegacyRulesEvaluator(IRuleProvider ruleProviders)
{
_ruleProviders = ruleProviders;
T = NullLocalizer.Instance;
}
