/// <summary>
/// Compiles all rules in the repository into a session factory.
/// Use <see cref="RuleCompiler"/> explicitly if only need to compile a subset of rules.
/// </summary>
/// <param name="repository">Rule repository.</param>
/// <returns>Session factory.</returns>
/// <seealso cref="RuleCompiler"/>
public static ISessionFactory Compile(this IRuleRepository repository)
{
var compiler = new RuleCompiler();
ISessionFactory factory = compiler.Compile(repository.GetRules());
return(factory);
}
public UpdateRuleService(
IUpdateRuleValidator updateRuleValidator,
IRuleRepository ruleRepository)
{
this.updateRuleValidator = updateRuleValidator;
this.ruleRepository = ruleRepository;
}
public RuleAppSercvice(RuleManager barcodeRuleManager, UnitOfWork unitOfWork, LogManager logManager, IRuleRepository ruleRepository)
{
_barcodeRuleManager = barcodeRuleManager;
_unitOfWork = unitOfWork;
_logManager = logManager;
_ruleRepository = ruleRepository;
}
public HtmlRuleExecutor(IRuleRepository repository, IXmlDocumentBuilder documentBuilder,
IXmlNamespaceManagerBuilder namespaceManagerBuilder)
{
_repository = repository;
_documentBuilder = documentBuilder;
_namespaceManagerBuilder = namespaceManagerBuilder;
}
public AddController(IAuthManager authManager, IChannelRepository channelRepository, IRuleRepository ruleRepository, IBlockManager blockManager)
{
_authManager = authManager;
_channelRepository = channelRepository;
_ruleRepository = ruleRepository;
_blockManager = blockManager;
}
public static void CreateRule(IRuleRepository ruleRepository, string name, RuleType ruleType, int ruleOrder, string ruleText)
{
var rule = new Rule(new RuleId(ruleRepository.GetNextId()), name, ruleText, ruleType, ruleOrder);
ruleRepository.Add(rule);
rules.Add(rule);
}
protected RuleServiceBase(IRuleRepository ruleRepository, ILogger logger)
{
this.RuleRepository = ruleRepository;
this.Logger = logger;
this.RuleFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "rules.json");
this._rules = new Lazy <ObservableCollection <IRule> >(this.GetRulesCollection);
}
public AccountService(IUnitOfWork uow, IMediator bus, INotificationHandler <DomainNotification> notifications,
IAccountRepository accountRepository,
IRuleRepository ruleRepository) : base(uow, bus, notifications)
{
_accountRepository = accountRepository;
_ruleRepository = ruleRepository;
}
public RuleService(
IRuleRepository ruleRepository,
ILogger logger,
IRulesRunner rulesRunner)
: base(ruleRepository, logger)
{
this._rulesRunner = rulesRunner;
}
public UserService(IUserRepository userRepository, IRuleRepository ruleRepository, ITeamRepository teamRepository, IUnitOfWork unitOfWork, IPaymentRecordService paymentRecordService)
{
this._userRepository = userRepository;
this._ruleRepository = ruleRepository;
this._teamRepository = teamRepository;
this._unitOfWork = unitOfWork;
this._paymentRecordService = paymentRecordService;
}
public RulesController(ICommandBus commandBus,
IRuleRepository rulesRepository,
IRuleEventRepository ruleEventsRepository)
: base(commandBus)
{
this.rulesRepository = rulesRepository;
this.ruleEventsRepository = ruleEventsRepository;
}
public RuleApplicationServiceTest() : base()
{
CreateScope();
_ruleApplicationService = GetIntanceScope <IRuleApplicationService>();
_ruleRepository = GetIntanceScope <IRuleRepository>();
_unitOfWork = GetIntanceScope <IUnitOfWork>();
}
public RuleService(IRuleRepository ruleRepository,
IMapper mapper)
{
_mapper = mapper ??
throw new ArgumentNullException(nameof(_mapper));
_ruleRepository = ruleRepository ??
throw new ArgumentNullException(nameof(_ruleRepository));
}
public RulesEvaluator(
ICachedEvaluatorFactory cachedEvaluatorFactory,
IRuleRepository ruleRepository,
ITransactionCategoryService transactionCategoryService)
{
this.cachedEvaluatorFactory = cachedEvaluatorFactory;
this.ruleRepository = ruleRepository;
this.transactionCategoryService = transactionCategoryService;
}
public AddController(IAuthManager authManager, IRuleRepository ruleRepository, ISiteRepository siteRepository, IChannelRepository channelRepository, IContentRepository contentRepository, ITableStyleRepository tableStyleRepository)
{
_authManager = authManager;
_ruleRepository = ruleRepository;
_siteRepository = siteRepository;
_channelRepository = channelRepository;
_contentRepository = contentRepository;
_tableStyleRepository = tableStyleRepository;
}
public AdminsService(IAdminRepository adminRepository, ICarRepository carRepository,
IOwnerRepository ownerRepository,
IRuleRepository ruleRepository)
{
this.adminRepository = adminRepository;
this.carRepository = carRepository;
this.ownerRepository = ownerRepository;
this.ruleRepository = ruleRepository;
}
public SpellCheckController(
IWebAgent agent,
IRuleRepository ruleRepository,
ISpellChecker spellChecker)
{
_agent = agent;
_ruleRepository = ruleRepository;
_spellChecker = spellChecker;
}
public SingleController(IAuthManager authManager, IGatherManager gatherManager, IRuleRepository ruleRepository, ISiteRepository siteRepository, IChannelRepository channelRepository, IContentRepository contentRepository)
{
_authManager = authManager;
_gatherManager = gatherManager;
_ruleRepository = ruleRepository;
_siteRepository = siteRepository;
_channelRepository = channelRepository;
_contentRepository = contentRepository;
}
public TestingContentController(IAuthManager authManager, IGatherManager gatherManager, IRuleRepository ruleRepository, ISiteRepository siteRepository, IChannelRepository channelRepository, IContentRepository contentRepository, ITableStyleRepository tableStyleRepository)
{
_authManager = authManager;
_gatherManager = gatherManager;
_ruleRepository = ruleRepository;
_siteRepository = siteRepository;
_channelRepository = channelRepository;
_contentRepository = contentRepository;
_tableStyleRepository = tableStyleRepository;
}
public RuleTypesController(IRuleTypeRepository ruleTypeRepository, IRuleRepository ruleRepository,
IAutopilotRuleRepository autopilotRuleRepository, IFlexibilityLevelRepository flexibilityLevelRepository,
IMapper mapper)
{
_ruleTypeRepository = ruleTypeRepository;
_ruleRepository = ruleRepository;
_autopilotRuleRepository = autopilotRuleRepository;
_flexibilityLevelRepository = flexibilityLevelRepository;
_mapper = mapper;
}
/// <summary>
/// Creates a new context from a passed in Context Id
/// </summary>
/// <param name="contextId"></param>
/// <param name="ruleExecuter"></param>
/// <param name="ruleRepository"></param>
/// <param name="ruleTemplateFactory"></param>
/// <returns></returns>
public static async Task <RuleContext <TFact, TOutput> > CreateContext(
Guid contextId,
IRuleExecuter <TFact, TOutput> ruleExecuter,
IRuleRepository ruleRepository,
IRuleTemplateFactory <TFact, TOutput> ruleTemplateFactory)
{
await ruleRepository.AddContext(contextId);
return(new RuleContext <TFact, TOutput>(ruleExecuter, ruleRepository, contextId, ruleTemplateFactory));
}
public PolicyService(IPolicyRepository policyRepository,
IRiskTypeRepository riskTypeRepository,
IRuleRepository ruleRepository,
IPolicyTypeRepository policyTypeRepository)
{
_policyRepository = policyRepository;
_riskTypeRepository = riskTypeRepository;
_ruleRepository = ruleRepository;
_policyTypeRepository = policyTypeRepository;
}
public GatherManager(IPathManager pathManager, ICacheManager cacheManager, ITaskManager taskManager, ISiteRepository siteRepository, IChannelRepository channelRepository, IContentRepository contentRepository, IRuleRepository ruleRepository)
{
_pathManager = pathManager;
_cacheManager = cacheManager;
_taskManager = taskManager;
_siteRepository = siteRepository;
_channelRepository = channelRepository;
_contentRepository = contentRepository;
_ruleRepository = ruleRepository;
}
public void Build(IRuleRepository ruleRepository)
{
if (ruleRepository == null)
{
throw new ArgumentNullException(nameof(ruleRepository));
}
_context = new Context();
_context.Build(ruleRepository);
}
private RuleContext(
IRuleExecuter <TFact, TOutput> ruleExecuter,
IRuleRepository ruleRepository,
Guid contextId,
IRuleTemplateFactory <TFact, TOutput> ruleTemplateFactory)
{
RuleExecuter = ruleExecuter;
_ruleRepository = ruleRepository;
ContextId = contextId;
_ruleTemplateFactory = ruleTemplateFactory;
}
/// <summary>
/// Creates a new empty Context
/// </summary>
/// <param name="ruleExecuter"></param>
/// <param name="ruleRepository"></param>
/// <param name="ruleTemplateFactory">The injected abstract factory to create the rules</param>
/// <returns></returns>
public static async Task <RuleContext <TFact, TOutput> > CreateContext(
IRuleExecuter <TFact, TOutput> ruleExecuter,
IRuleRepository ruleRepository,
IRuleTemplateFactory <TFact, TOutput> ruleTemplateFactory)
{
var newGuid = Guid.NewGuid();
return
(await
CreateContext(newGuid, ruleExecuter, ruleRepository, ruleTemplateFactory));
}
public TransactionConfirmationWatcher(
ICallbackRepository callbackRepository,
IRuleRepository ruleRepository,
IBlocksStorage blocks,
ICallbackExecuter callbackExecuter,
IWatchRepository watchRepository,
ILogger <TransactionConfirmationWatcher> logger)
{
if (callbackRepository == null)
{
throw new ArgumentNullException(nameof(callbackRepository));
}
if (ruleRepository == null)
{
throw new ArgumentNullException(nameof(ruleRepository));
}
if (blocks == null)
{
throw new ArgumentNullException(nameof(blocks));
}
if (callbackExecuter == null)
{
throw new ArgumentNullException(nameof(callbackExecuter));
}
if (watchRepository == null)
{
throw new ArgumentNullException(nameof(watchRepository));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.callbackRepository = callbackRepository;
this.ruleRepository = ruleRepository;
this.watchRepository = watchRepository;
this.callbackExecuter = callbackExecuter;
this.logger = logger;
this.watcher = new Zcoin.Watching.TransactionConfirmationWatcher <Rule>
(
this,
blocks
);
this.timers = new Dictionary <uint256, Dictionary <Guid, Timer> >();
this.timerLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
}
public RuleService(
ICreateRuleConversionProfile createRuleConversionProfile,
ICreateRuleService createRuleService,
IRuleRepository ruleRepository,
IUpdateRuleConversionProfile updateRuleConversionProfile,
IUpdateRuleService updateRuleService)
{
this.createRuleConversionProfile = createRuleConversionProfile;
this.createRuleService = createRuleService;
this.ruleRepository = ruleRepository;
this.updateRuleConversionProfile = updateRuleConversionProfile;
this.updateRuleService = updateRuleService;
}
public AutopilotSettingsController(IAutopilotSettingsRepository autopilotSettingsRepository,
IAutopilotRuleRepository autopilotRuleRepository, IRuleRepository ruleRepository,
IRuleTypeRepository ruleTypeRepository,
IModelDataValidator <UpdateAutopilotSettingsModel> autopilotSettingsValidator,
IMapper mapper)
{
_autopilotSettingsRepository = autopilotSettingsRepository;
_autopilotRuleRepository = autopilotRuleRepository;
_ruleRepository = ruleRepository;
_ruleTypeRepository = ruleTypeRepository;
_autopilotSettingsValidator = autopilotSettingsValidator;
_mapper = mapper;
}
public RuleEnqueuer(
IRuleEventRepository ruleEventRepository,
IRuleRepository ruleRepository,
RuleService ruleService)
{
Guard.NotNull(ruleEventRepository, nameof(ruleEventRepository));
Guard.NotNull(ruleRepository, nameof(ruleRepository));
Guard.NotNull(ruleService, nameof(ruleService));
this.ruleEventRepository = ruleEventRepository;
this.ruleRepository = ruleRepository;
this.ruleService = ruleService;
}
public RuleController()
{
_rules = new RuleRepository(_db);
}
public void Init()
{
Database.Delete("LighthouseContext"); // Verify that database does not exist
var initializer = new LighthouseInitializer(); // Create and initialize new database
_db = new LighthouseContext();
initializer.InitializeDatabase(_db);
Assert.IsNotNull(_db, "Database creation failed."); // Fail tests if database does not exist
_rules = new RuleRepository(_db);
Assert.IsNotNull(_rules, "Rule repository could not be created.");
}
