public ExportedTableColumnPrimaryComponent(string key, string title, IRulesRepository rulesRepository, Func <TInput, string> rulesExtractor, Func <TInput, PerformanceDto> performanceExtractor)
: base(key, title)
{
this.rulesRepository = rulesRepository;
this.rulesExtractor = rulesExtractor;
this.performanceExtractor = performanceExtractor;
}
public ApiSetup(IRepositorySetProvider repositorySetProvider, IRulesRepository rulesProvider, IRacesIndexRepository racesIndexRepository, SearchTokenizer tokenizer)
{
this.repositorySetProvider = repositorySetProvider;
this.rulesProvider = rulesProvider;
this.racesIndexRepository = racesIndexRepository;
this.tokenizer = tokenizer;
}
public RulesController(IMapper mapper, IUnitOfWork unitOfWork, ILogger <RulesController> logger, IRulesRepository rulesRepository)
{
_mapper = mapper;
_unitOfWork = unitOfWork;
_rulesRepository = rulesRepository;
_logger = logger;
}
private SchemaValidation.Provider CreateSchemaProvider(ITweek tweek, IRulesRepository rulesProvider, SchemaValidation.Mode mode)
{
var logger = loggerFactory.CreateLogger("SchemaValidation.Provider");
SchemaValidation.Provider CreateValidationProvider()
{
logger.LogInformation("updating schema");
var schemaValues = tweek.Calculate(new[] { new ConfigurationPath("@tweek/schema/_") }, EmptyIdentitySet,
i => ContextHelpers.EmptyContext);
schemaValues.EnsureSuccess();
var schemaIdentities = schemaValues.ToDictionary(x => x.Key.Name, x => x.Value.Value);
var customTypesValues = tweek.Calculate(new[] { new ConfigurationPath("@tweek/custom_types/_") }, EmptyIdentitySet,
i => ContextHelpers.EmptyContext);
customTypesValues.EnsureSuccess();
var customTypes = customTypesValues.ToDictionary(x => x.Key.Name, x => CustomTypeDefinition.FromJsonValue(x.Value.Value));
return(SchemaValidation.Create(schemaIdentities, customTypes, mode));
}
var validationProvider = CreateValidationProvider();
rulesProvider.OnRulesChange += (_) => {
validationProvider = CreateValidationProvider();
};
return((p) => validationProvider(p));
}
public TestScope(IRulesRepository rules, IContextDriver context, Func <Task> init, Func <Task> dispose)
{
mRulesRepository = rules;
_contextDriver = context;
_init = init;
_dispose = dispose;
}
public ResultsListExporter(IRulesRepository rulesRepository)
{
AddAthleteField("Athlete.AthleteId", "ID", e => e.AthleteId);
AddAthleteField("Athlete.FirstName", "First name", e => e.FirstName);
AddAthleteField("Athlete.Surname", "Surname", e => e.Surname);
AddAthleteField("Athlete.FullName", "Name", e => ExportedTableColumnExtractors.AthleteFullName(e));
AddAthleteField("Athlete.Club", "Club", e => e.Club);
AddAthleteField("Athlete.CountryName", "Country", e => e.CountryName);
AddAthleteField("Athlete.Sex", "Sex", e => e.Sex);
AddAthleteField("Athlete.Category", "Category", e => e.Category);
AddAthleteField("Athlete.ModeratorNotes", "Notes", e => e.ModeratorNotes);
AddResultsField("Announcement.Duration", "Announced", e => ExportedTableColumnExtractors.PerformanceDuration(e.Announcement?.Performance));
AddResultsField("Announcement.Depth", "Announced", e => ExportedTableColumnExtractors.PerformanceDepth(e.Announcement?.Performance));
AddResultsField("Announcement.Distance", "Announced", e => ExportedTableColumnExtractors.PerformanceDistance(e.Announcement?.Performance));
AddResultsField("Announcement.Points", "Announced", e => ExportedTableColumnExtractors.PerformancePoints(e.Announcement?.Performance));
AddResultsField("Announcement.Combined", "Announced", e => ExportedTableColumnExtractors.PerformanceCombined(e.Announcement?.Performance));
AddResultsField("CurrentResult.Actual.Duration", "Realized", e => ExportedTableColumnExtractors.PerformanceDuration(e.CurrentResult?.Performance));
AddResultsField("CurrentResult.Actual.Depth", "Realized", e => ExportedTableColumnExtractors.PerformanceDepth(e.CurrentResult?.Performance));
AddResultsField("CurrentResult.Actual.Distance", "Realized", e => ExportedTableColumnExtractors.PerformanceDistance(e.CurrentResult?.Performance));
AddResultsField("CurrentResult.Actual.Points", "Realized", e => ExportedTableColumnExtractors.PerformancePoints(e.CurrentResult?.Performance));
AddResultsField("CurrentResult.Actual.Combined", "Realized", e => ExportedTableColumnExtractors.PerformanceCombined(e.CurrentResult?.Performance));
AddResultsField("CurrentResult.Final.Duration", "Realized", e => ExportedTableColumnExtractors.PerformanceDuration(e.CurrentResult?.FinalPerformance));
AddResultsField("CurrentResult.Final.Depth", "Realized", e => ExportedTableColumnExtractors.PerformanceDepth(e.CurrentResult?.FinalPerformance));
AddResultsField("CurrentResult.Final.Distance", "Realized", e => ExportedTableColumnExtractors.PerformanceDistance(e.CurrentResult?.FinalPerformance));
AddResultsField("CurrentResult.Final.Points", "Realized", e => ExportedTableColumnExtractors.PerformancePoints(e.CurrentResult?.FinalPerformance));
AddResultsField("CurrentResult.Final.Combined", "Realized", e => ExportedTableColumnExtractors.PerformanceCombined(e.CurrentResult?.FinalPerformance));
AddResultsField("FinalPoints", "Points", e => ExportedTableColumnExtractors.Points(e.FinalPoints));
AddResultsField("FinalPointsTotal", "", e => ExportedTableColumnExtractors.Points(e.FinalPoints));
}
public string SelectDetailGroup(IRulesRepository repository, string group, string subGroup)
{
var window = new DetailSelector(repository, group, subGroup);
window.ShowDialog();
return(window.FoundDetail);
}
public string SelectDetailGroup(IRulesRepository repository)
{
var window = new DetailGroupSelector(repository);
window.ShowDialog();
return(window.FoundDetailGroup);
}
public static async Task <TweekIdentityProvider> Create(IRulesRepository repository)
{
var allRules = await repository.GetAllRules();
var initialIdentities = ExtractIdentitiesWithAuth(allRules.Keys);
return(new TweekIdentityProvider(repository, initialIdentities));
}
public TransferController(ILogger <TransferController> logger, IRulesRepository rulesRepository, IRulesCache rulesCache, IRulesManager rulesManager, IFlowManager flowManager)
{
_logger = logger;
_rulesRepository = rulesRepository;
this._rulesCache = rulesCache;
this._rulesManager = rulesManager;
this._flowManager = flowManager;
}
public RulesRepositoryHealthCheck(IRulesRepository repository, IConfiguration config)
: base("RulesRepository")
{
_repository = repository;
var failureDelayInMs = config.GetValue("Rules:FailureDelayInMs", 60000);
_degradedTimeout = TimeSpan.FromMilliseconds(failureDelayInMs * 5);
_unhelthyTimeout = TimeSpan.FromMilliseconds(failureDelayInMs * 60);
}
public RulesRepositoryHealthCheck(IRulesRepository repository, IConfiguration config, IServiceProvider serviceProvider)
{
_repository = repository;
var failureDelayInMs = config.GetValue("Rules:FailureDelayInMs", 60000);
_degradedTimeout = TimeSpan.FromMilliseconds(failureDelayInMs * 5);
_unhealthyTimeout = TimeSpan.FromMilliseconds(failureDelayInMs * 60);
_serviceProvider = serviceProvider;
}
public RuleService(
IRulesRepository rulesRepository,
IOptionsRepository optionsRepository,
IMapper mapper)
{
this.rulesRepository = rulesRepository;
this.optionsRepository = optionsRepository;
this.mapper = mapper;
}
public static async Task <Func <(GetRule, PathExpander)> > Factory(IRulesRepository repository, GetRuleParser parserResolver)
{
(GetRule, PathExpander)? instance = null;
repository.OnRulesChange += (newRules) => instance = Parse(newRules, parserResolver);
var initRepo = Parse(await repository.GetAllRules(), parserResolver);
instance = instance ?? initRepo;
return(() => instance.Value);
}
private TweekIdentityProvider(IRulesRepository repository, HashSet <string> initialIdentitiesWithAuth)
{
_identitiesWithAuth = initialIdentitiesWithAuth;
repository.OnRulesChange += (newRules) =>
{
_identitiesWithAuth = ExtractIdentitiesWithAuth(newRules.Keys);
};
}
public static async Task <Func <(GetRule, PathExpander)> > Factory(IRulesRepository repository, GetRuleParser parserResolver)
{
var instance = Parse(await repository.GetAllRules(), parserResolver);
repository.OnRulesChange += (newRules) =>
{
using (TraceHelpers.TraceTime("loading new rules"))
{
instance = Parse(newRules, parserResolver);
}
};
return(() => instance);
}
public static IEnumerable<DocumentItem> GetDocumentItemsFromXml(string itemDataXml, string itemCircDataXml, IRulesRepository rulesRepository)
{
var documentItems = new List<DocumentItem>();
var xmlDoc = XDocument.Parse(itemDataXml);
if (xmlDoc.Root != null)
{
var items = xmlDoc.Root.Descendants("item");
foreach (var item in items)
{
var docItem = new DocumentItem();
docItem.ItemKey = GetValueFromXElement(item, "rec-key");
docItem.Branch = GetValueFromXElement(item, "sub-library");
string dep = string.Empty;
DepartmentCodeDictionary.TryGetValue(GetValueFromXElement(item, "collection"), out dep);
docItem.Department = dep;
docItem.ItemStatus = GetValueFromXElement(item, "item-status");
docItem.PlacementCode = GetValueFromXElement(item, "call-no-1");
docItem.OnHold = "Y".Equals(GetValueFromXElement(item, "on-hold"));
docItem.InTransit = "Y".Equals(GetValueFromXElement(item, "loan-in-transit"));
docItem.LoanStatus = GetValueFromXElement(item, "loan-status");
docItem.Barcode = GetValueFromXElement(item, "barcode");
var loanDueDateAsString = GetValueFromXElement(item, "loan-due-date");
if (loanDueDateAsString != null)
docItem.LoanDueDate = ParseLoanDate(loanDueDateAsString);
docItem.ItemAdmKey = docItem.ItemKey.Substring(0, 9);
docItem.ItemKeySequence = docItem.ItemKey.Substring(9, 6);
documentItems.Add(docItem);
}
}
xmlDoc = XDocument.Parse(itemCircDataXml);
if (xmlDoc.Root != null)
{
var items = xmlDoc.Root.Descendants("item-data");
foreach (var item in items)
{
var barcode = GetValueFromXElement(item, "barcode");
var itemStatusText = GetValueFromXElement(item, "loan-status");
var dueDateText = GetValueFromXElement(item, "due-date");
var processText = itemStatusText ?? dueDateText;
var docItem =
documentItems.Where(x => x.Barcode.Equals(barcode)).Select(x => x).ToList().FirstOrDefault();
if (docItem != null)
docItem.ItemProcessStatusText = processText;
var noReqTmp = GetValueFromXElement(item, "no-requests");
if (string.IsNullOrEmpty(noReqTmp))
{
docItem.NoRequests = 0;
} else {
var noReqSplitted = noReqTmp.Split('(');
if (noReqSplitted[0] != null)
{
var tmp = noReqSplitted[0].Trim();
var noReqParsed = 0;
int.TryParse(tmp, out noReqParsed);
docItem.NoRequests = noReqParsed;
}
}
}
}
foreach (var documentItem in documentItems)
{
documentItem.IsReservable = IsReservableItem(documentItem, rulesRepository);
}
return documentItems;
}
public RetirementService(IRulesRepository repository)
{
var rules = repository.GetRules("RetirementEligibility.json");
_engine = new RulesEngine.RulesEngine(rules, null);
}
public Rule(IRulesRepository rulesRepository, ICacheStorage cacheStorage)
: base(rulesRepository, cacheStorage)
{
}
public UpdateJob(IYoutubeService ytService, IRulesRepository rulesRepository)
{
this.ytService = ytService;
this.rulesRepository = rulesRepository;
}
public RuleController(IRulesRepository repository)
{
_repository = repository;
}
public void InitRepository()
{
_repository = new RulesRepository(_pathToRulesFolder);
}
public TestModelConvertionFromXml()
{
_repository = new RulesRepository(_pathToRulesFolder);
}
public RulesManager(IRulesRepository repository, IOptions <ApplicationOptions> optionsAccessor, IRulesCache rulesCache)
{
this._repository = repository;
this._applicationOptions = optionsAccessor.Value;
this._rulesCache = rulesCache;
}
public RepoVersionController(IRulesRepository rulesRepository)
{
mRulesRepository = rulesRepository;
}
public ApiRules(IRulesRepository rulesRepository)
{
this.rulesRepository = rulesRepository;
}
public RulesController(IRulesRepository _rulesRepository)
{
rulesRepository = _rulesRepository;
}
private static bool IsReservableItem(DocumentItem docItem, IRulesRepository rulesRepository)
{
var processText = docItem.ItemProcessStatusText;
var itemStatusCode = docItem.ItemStatus;
var rules = rulesRepository.GetItemRules();
// No rules, no reservations
if (rules == null)
return false;
// Nothing to get rules from, no reservation
if (itemStatusCode == null && processText == null)
return false;
// Check rule for matching item status
var itemStatusCodeRule = rules.Where(x => x.ItemStatus.Equals(itemStatusCode)).Select(x => x).ToList().FirstOrDefault();
if (itemStatusCode != null && itemStatusCodeRule != null && !itemStatusCodeRule.CanReserve)
return false;
// Check rule for matching processText
ItemRule ruleFromProcessText = null;
if (processText != null)
ruleFromProcessText = rules.Where(x => x.ProcessStatusText.Equals(processText)).Select(x => x).ToList().FirstOrDefault();
if (processText != null && ruleFromProcessText != null && !ruleFromProcessText.CanReserve)
return false;
// Check if processTextCode is legal if any
if (ruleFromProcessText != null)
{
var processTextCode = ruleFromProcessText.ProcessStatusCode;
string[] legalCodes = { "##", "EN", "NA", "NB", "UL", "IU" };
if (!legalCodes.Contains(processTextCode))
return false;
}
// Legal!
return true;
}
public StartingListExporter(IRulesRepository rulesRepository)
{
availableColumns = new Dictionary <string, IExportedTableColumn <StartingListReportEntry> >();
AddColumn("Athlete.AthleteId", "ID", e => e.Athlete.AthleteId);
AddColumn("Athlete.FirstName", "First name", e => e.Athlete.FirstName);
AddColumn("Athlete.Surname", "Surname", e => e.Athlete.Surname);
AddColumn("Athlete.FullName", "Name", e => ExportedTableColumnExtractors.AthleteFullName(e.Athlete));
AddColumn("Athlete.Club", "Club", e => e.Athlete.Club);
AddColumn("Athlete.CountryName", "Country", e => e.Athlete.CountryName);
AddColumn("Athlete.Sex", "Sex", e => e.Athlete.Sex);
AddColumn("Athlete.Category", "Category", e => e.Athlete.Category);
AddColumn("Athlete.ModeratorNotes", "Notes", e => e.Athlete.ModeratorNotes);
AddColumn("Discipline.DisciplineId", "Discipline", e => e.Discipline.DisciplineId);
AddColumn("Discipline.Name", "Discipline", e => e.Discipline.Name);
AddColumn("Discipline.Rules", "Rules", e => e.Discipline.Rules);
AddColumn("Announcement.Duration", "Announced", e => ExportedTableColumnExtractors.PerformanceDuration(e.Announcement?.Performance));
AddColumn("Announcement.Depth", "Announced", e => ExportedTableColumnExtractors.PerformanceDepth(e.Announcement?.Performance));
AddColumn("Announcement.Distance", "Announced", e => ExportedTableColumnExtractors.PerformanceDistance(e.Announcement?.Performance));
AddColumn("Announcement.Points", "Announced", e => ExportedTableColumnExtractors.PerformancePoints(e.Announcement?.Performance));
AddColumn(new ExportedTableColumnPrimaryComponent <StartingListReportEntry>(
"Announcement.Primary", "Announced", rulesRepository, e => e.Discipline.Rules, e => e.Announcement?.Performance));
AddColumn("Start.StartingLaneId", "Lane", e => e.Start.StartingLaneId);
AddColumn("Start.StartingLaneLongName", "Lane", e => e.Start.StartingLaneLongName);
AddColumn("Start.WarmUpTime", "WU", e => ExportedTableColumnExtractors.StartTime(e.Start.WarmUpTime));
AddColumn("Start.OfficialTop", "OT", e => ExportedTableColumnExtractors.StartTime(e.Start.OfficialTop));
AddColumn("CurrentResult.Actual.Duration", "Realized", e => ExportedTableColumnExtractors.PerformanceDuration(e.CurrentResult?.FinalPerformance));
AddColumn("CurrentResult.Actual.Depth", "Realized", e => ExportedTableColumnExtractors.PerformanceDepth(e.CurrentResult?.FinalPerformance));
AddColumn("CurrentResult.Actual.Distance", "Realized", e => ExportedTableColumnExtractors.PerformanceDistance(e.CurrentResult?.FinalPerformance));
AddColumn("CurrentResult.Actual.Points", "Realized", e => ExportedTableColumnExtractors.PerformancePoints(e.CurrentResult?.FinalPerformance));
AddColumn(new ExportedTableColumnPrimaryComponent <StartingListReportEntry>(
"CurrentResult.Actual.Primary", "Realized", rulesRepository, e => e.Discipline.Rules, e => e.CurrentResult?.Performance));
AddColumn("CurrentResult.Final.Duration", "Realized", e => ExportedTableColumnExtractors.PerformanceDuration(e.CurrentResult?.FinalPerformance));
AddColumn("CurrentResult.Final.Depth", "Realized", e => ExportedTableColumnExtractors.PerformanceDepth(e.CurrentResult?.FinalPerformance));
AddColumn("CurrentResult.Final.Distance", "Realized", e => ExportedTableColumnExtractors.PerformanceDistance(e.CurrentResult?.FinalPerformance));
AddColumn("CurrentResult.Final.Points", "Realized", e => ExportedTableColumnExtractors.PerformancePoints(e.CurrentResult?.FinalPerformance));
AddColumn(new ExportedTableColumnPrimaryComponent <StartingListReportEntry>(
"CurrentResult.Final.Primary", "Realized", rulesRepository, e => e.Discipline.Rules, e => e.CurrentResult?.Performance));
AddColumn("CurrentResult.CardResult", "Card", e => e.CurrentResult?.CardResult);
AddColumn("CurrentResult.JudgeComment", "Comment", e => e.CurrentResult?.JudgeComment);
minimal = BuildExporter(
"Athlete.FullName",
"Athlete.CountryName",
"Start.OfficialTop",
"Start.StartingLaneLongName",
"Announcement.Primary"
);
running = BuildExporter(
"Athlete.FullName",
"Athlete.CountryName",
"Start.OfficialTop",
"Start.StartingLaneLongName",
"Announcement.Primary",
"CurrentResult.Actual.Primary",
"CurrentResult.CardResult",
"CurrentResult.JudgeComment"
);
}
public MonthlyJobProvider()
{
_rules = new RulesRepository();
_charge = new ChargeRepository();
}
public RulesService(IRulesRepository rulesRepository, IMapper mapper)
{
this._rulesRepository = rulesRepository;
this._mapper = mapper;
}
public ApiAthlete(IRepositorySetProvider repositorySetProvider, IRulesRepository rulesRepository)
{
this.repositorySetProvider = repositorySetProvider;
this.rulesRepository = rulesRepository;
}
public RulesController(IRulesRepository rulesRepository)
{
this._rulesRepository = rulesRepository;
}
public RuleService(IRulesRepository rulesRepository, ICacheStorage cacheStorage)
{
_rulesRepository = rulesRepository;
_cacheStorage = cacheStorage;
}
public RulesLoader(IRulesRepository repository, IOptions <ApplicationOptions> optionsAccessor, ILogger <RulesLoader> logger)
{
this._repository = repository;
this._applicationOptions = optionsAccessor.Value;
this._logger = logger;
}
