private IReadOnlyCollection <Version.ValidationResult> QueryTarget(MessageTypeCode messageType, long version)
{
using (Probe.Create("Query Cache"))
{
if (_cache.TryGet(messageType, out var targetValidationResults))
{
return(targetValidationResults);
}
}
using (Probe.Create("Query Target"))
{
var targetValidationResults =
_query
.For <Version.ValidationResult>()
.Where(x => x.MessageType == (int)messageType)
.ForVersion(version)
.ApplyVersionId(0)
.ToList();
_cache.Initialize(messageType, targetValidationResults);
return(targetValidationResults);
}
}
private static Tuple <MessageTypeCode, IReadOnlyDictionary <CheckMode, RuleSeverityLevel> > Rule(
MessageTypeCode rule,
RuleSeverityLevel?single = null,
RuleSeverityLevel?singleForCancel = null,
RuleSeverityLevel?singleForApprove = null,
RuleSeverityLevel?manualReport = null,
RuleSeverityLevel?manualReportWithAccount = null,
RuleSeverityLevel?prerelease = null,
RuleSeverityLevel?release = null)
{
if (manualReport.HasValue && !manualReportWithAccount.HasValue)
{
manualReportWithAccount = manualReport;
}
var values = new Dictionary <CheckMode, RuleSeverityLevel?>
{
{ CheckMode.Single, single },
{ CheckMode.SingleForCancel, singleForCancel },
{ CheckMode.SingleForApprove, singleForApprove },
{ CheckMode.Manual, manualReport },
{ CheckMode.ManualWithAccount, manualReportWithAccount },
{ CheckMode.Prerelease, prerelease },
{ CheckMode.Release, release },
};
return(new Tuple <MessageTypeCode, IReadOnlyDictionary <CheckMode, RuleSeverityLevel> >(rule, values.Where(x => x.Value.HasValue).ToDictionary(x => x.Key, x => x.Value.Value)));
}
public void Update(MessageTypeCode messageType, IReadOnlyCollection <Version.ValidationResult> value)
{
var result = new Cache.ValidationResult {
MessageType = messageType, Data = Serialize(value)
};
_repository.Update(result);
_repository.Save();
}
public bool TryGet(MessageTypeCode messageType, out IReadOnlyCollection <Version.ValidationResult> value)
{
var cachedResult = _query.For <Cache.ValidationResult>().SingleOrDefault(x => x.MessageType == messageType);
if (cachedResult == null)
{
value = null;
return(false);
}
value = Deserialize(cachedResult.Data);
return(true);
}
private void UpdateCache(MessageTypeCode messageType, IReadOnlyCollection <Version.ValidationResult> existing, IReadOnlyCollection <Version.ValidationResult> newResults, IReadOnlyCollection <Version.ValidationResult> resolvedResults)
{
if (newResults.Count == 0 && resolvedResults.Count == 0)
{
return;
}
using (Probe.Create("Update Cache"))
{
var hs = new HashSet <Version.ValidationResult>(existing, _equalityComparer);
hs.UnionWith(newResults);
hs.ExceptWith(resolvedResults);
_cache.Update(messageType, hs);
}
}
public void TestRule(MessageTypeCode rule)
{
var results = GetResultsFromBigDatabase(x => x.MessageType == (int)rule && x.OrderId.HasValue);
if (!results.Any())
{
Assert.Inconclusive();
}
var expectedResultsByOrder = results.GroupBy(x => x.OrderId.Value, x => x).Take(OrderPerRule).ToArray();
var validator = new PipelineFactory().Create();
foreach (var expected in expectedResultsByOrder)
{
var actual = validator.Execute(expected.Key, TestCheckMode.SingleRule(rule)).ToArray();
AssertCollectionsEqual(MergePeriods(expected), MergePeriods(actual));
}
}
public RecalculateValidationRulePartiallyCommand(MessageTypeCode rule, IReadOnlyCollection <long> filter) => (Rule, Filter) = (rule, filter);
private IDistinctor DistinctorForMessageType(MessageTypeCode messageType)
{
return(_distinctors.TryGetValue(messageType, out var distinctor) ? distinctor : Default);
}
public RecalculateValidationRuleCompleteCommand(MessageTypeCode rule)
{
Rule = rule;
}
public void Add(MessageTypeCode ruleCode, Func <IReadOnlyCollection <T>, IReadOnlyCollection <long> > onChange) => _dictionary.Add(ruleCode, x => x.Any() ? new ResultPartiallyOutdatedEvent(ruleCode, onChange.Invoke(x)) : null);
private MergeResult <Version.ValidationResult> CalculateValidationRuleChanges(IReadOnlyCollection <Version.ValidationResult> currentVersionResults, MessageTypeCode ruleCode, Expression <Func <Version.ValidationResult, bool> > filter)
{
try
{
List <Version.ValidationResult> sourceObjects;
using (Probe.Create("Query Source"))
using (new TransactionScope(TransactionScopeOption.RequiresNew, _transactionOptions))
{
// Запрос к данным посылаем вне транзакции, иначе будет DTC
var accessor = _accessors[ruleCode];
var query = accessor.GetSource().Where(filter);
sourceObjects = query.ToList();
}
using (Probe.Create("Merge"))
{
var destObjects = currentVersionResults.Where(x => x.MessageType == (int)ruleCode).Where(filter.Compile());
var mergeResult = MergeTool.Merge(sourceObjects, destObjects, _equalityComparer);
return(mergeResult);
}
}
catch (Exception ex)
{
throw new Exception($"Ошибка при вычислении правила {ruleCode}", ex);
}
}
public ResultPartiallyOutdatedEvent(MessageTypeCode rule, IReadOnlyCollection <long> orderIds) => (Rule, OrderIds) = (rule, orderIds);
protected ValidationResultAccessorBase(IQuery query, MessageTypeCode messageTypeId)
{
_query = query;
_messageTypeId = (int)messageTypeId;
}
public void Add(MessageTypeCode ruleCode) => _dictionary.Add(ruleCode, x => x.Any() ? new ResultOutdatedEvent(ruleCode) : null);
public void Add(MessageTypeCode ruleCode) => _outdated.Add(ruleCode);
public static TestCheckMode SingleRule(MessageTypeCode rule)
=> new TestCheckMode
{
Rules = new[] { rule }.ToDictionary(x => x, x => RuleSeverityLevel.None)
};
public RecalculateValidationRulePartiallyCommand(MessageTypeCode rule, IReadOnlyCollection <long> filter)
{
Rule = rule;
Filter = filter;
}
public void Add(MessageTypeCode ruleCode, Func <IReadOnlyCollection <T>, IEnumerable <long> > func) => _partiallyOutdated.Add(ruleCode, func);
public ResultOutdatedEvent(MessageTypeCode rule) => Rule = rule;
public ResultPartiallyOutdatedEvent(MessageTypeCode rule, IReadOnlyCollection <long> orderIds)
{
Rule = rule;
OrderIds = orderIds;
}
