public ReleaseController(VersioningService versioningService, ValidationResultRepositiory repository, ValidationResultFactory factory, CheckModeDescriptorFactory descriptorFactory)
{
_versioningService = versioningService;
_repository = repository;
_factory = factory;
_checkModeDescriptor = descriptorFactory.GetDescriptorFor(CheckMode.Release);
}
public SingleForApproveController(ValidationResultFactory factory, PipelineFactory pipelineFactory, CheckModeDescriptorFactory descriptorFactory, VersionHelper versionHelper)
{
_factory = factory;
_pipelineFactory = pipelineFactory;
_versionHelper = versionHelper;
_checkModeDescriptor = descriptorFactory.GetDescriptorFor(CheckMode.SingleForApprove);
}
public ManualWithAccountController(VersioningService versioningService, ValidationResultRepositiory repositiory, ValidationResultFactory factory, CheckModeDescriptorFactory descriptorFactory)
{
_versioningService = versioningService;
_repositiory = repositiory;
_factory = factory;
_checkModeDescriptor = descriptorFactory.GetDescriptorFor(CheckMode.ManualWithAccount);
}
public RuleSeverityLevel GetLevel(Message message, ICheckModeDescriptor checkModeDescriptor)
{
switch (message.MessageType)
{
case MessageTypeCode.OrderRequiredFieldsShouldBeSpecified:
// Понижаем уровень ошибки LegalPersonProfile до Warning для не Single проверок
// т.к. обычный заказ не может быть утвержден без выполнения этой проверки (error в Single проверке),
// а для самопродажных заказов она не имеет смысла (поэтому warning в массовых проверках)
var isLegalPersonProfile = bool.Parse(message.Extra["legalPersonProfile"]);
var isCurrency = bool.Parse(message.Extra["currency"]);
var isBranchOfficeOrganizationUnit = bool.Parse(message.Extra["branchOfficeOrganizationUnit"]);
var isLegalPerson = bool.Parse(message.Extra["legalPerson"]);
if (checkModeDescriptor.CheckMode != CheckMode.Single && !isCurrency &&
!isBranchOfficeOrganizationUnit && !isLegalPerson && isLegalPersonProfile)
{
return(RuleSeverityLevel.Warning);
}
break;
case MessageTypeCode.LinkedFirmAddressShouldBeValid:
var isPartnerAddress = bool.Parse(message.Extra["isPartnerAddress"]);
if (isPartnerAddress)
{
return(RuleSeverityLevel.Warning);
}
break;
}
return(GetConfiguredLevel(message, checkModeDescriptor));
}
public IReadOnlyCollection <Version.ValidationResult> Execute(long orderId, ICheckModeDescriptor checkModeDescriptor)
{
// todo: можно использовать checkModeDescriptor для дальнейшей оптимизации
var optimization = new Optimizer();
IStore Wrap(IStore store) => new OptimizerStore(optimization, store);
using (Probe.Create("Execute"))
using (var erm = new HashSetStoreFactory(_equalityComparerFactory))
using (var store = new PersistentTableStoreFactory(_equalityComparerFactory, _webAppMappingSchema))
using (var messages = new HashSetStoreFactory(_equalityComparerFactory))
{
IReadOnlyCollection <Replicator> factReplicators;
IReadOnlyCollection <Replicator> aggregateReplicators;
IReadOnlyCollection <Replicator> messageReplicators;
using (Probe.Create("Initialization"))
{
factReplicators = CreateReplicators(_factAccessorTypes, erm.CreateQuery(), Wrap(store.CreateStore()));
aggregateReplicators = CreateReplicators(_aggregateAccessorTypes, store.CreateQuery(), Wrap(store.CreateStore()));
messageReplicators = CreateReplicators(_messageAccessorTypes, store.CreateQuery(), Wrap(messages.CreateStore()))
.Where(x => x.DataObjectType == typeof(Version.ValidationResult) && checkModeDescriptor.Rules.ContainsKey(x.Rule)).ToList();
var predicates = factReplicators.Concat(aggregateReplicators).Concat(messageReplicators).SelectMany(x => x.DependencyPredicates);
optimization.PrepareToUse(predicates.ToHashSet());
}
ErmDataLoader.ResolvedOrderSummary orderSummary;
using (Probe.Create("Erm -> Erm slice"))
{
ReadErmSlice(orderId, Wrap(erm.CreateStore()), out orderSummary);
}
using (Probe.Create("Erm slice -> WebApp Facts"))
{
_strategy.ProcessFacts(factReplicators, aggregateReplicators, messageReplicators, optimization);
}
using (Probe.Create("WebApp Facts -> WebApp Aggregates"))
{
_strategy.ProcessAggregates(aggregateReplicators, messageReplicators, optimization);
}
using (Probe.Create("WebApp Aggregates -> WebApp Messages"))
{
_strategy.ProcessMessages(messageReplicators, optimization);
}
var validationPeriodStart = GetValidationPeriodStart(erm.CreateQuery(), orderId, checkModeDescriptor);
using (Probe.Create("Query result"))
{
return(messages.CreateQuery()
.For <Version.ValidationResult>()
.Where(x => x.OrderId == orderId && checkModeDescriptor.Rules.Keys.Contains((MessageTypeCode)x.MessageType) && x.PeriodEnd >= validationPeriodStart)
.ToList());
}
}
}
private static RuleSeverityLevel GetConfiguredLevel(Message message, ICheckModeDescriptor checkModeDescriptor)
{
if (!checkModeDescriptor.Rules.TryGetValue(message.MessageType, out var level))
{
throw new ArgumentException($"Could not find level for message '{message.MessageType}'");
}
return(level);
}
private static Expression <Func <Version.ValidationResult, bool> > ForMode(ICheckModeDescriptor checkModeDescriptor) => x => checkModeDescriptor.Rules.Keys.Contains((MessageTypeCode)x.MessageType);
public IReadOnlyCollection <Version.ValidationResult> GetResults(long versionId, IReadOnlyCollection <long> orderIds, long?projectId, DateTime start, DateTime end, ICheckModeDescriptor checkModeDescriptor)
{
using (var connection = _factory.CreateDataConnection(ConfigurationString))
{
var orderIdentities = ToTemporaryTable(connection, orderIds);
var validationResults = connection.GetTable <Version.ValidationResult>()
.Where(ForOrdersOrProject(orderIdentities, projectId))
.Where(ForPeriod(start, end))
.Where(ForMode(checkModeDescriptor))
.ForVersion(versionId);
return(validationResults.ToList());
}
}
private ValidationResult Compose(Message message, ResolvedNameContainer resolvedNames, ICheckModeDescriptor checkModeDescriptor)
{
try
{
if (!_composers.TryGetValue(message.MessageType, out var composer))
{
throw new ArgumentException($"Не найден сериализатор '{message.MessageType}'", nameof(message));
}
var composerResult = composer.Compose(message.References.Select(resolvedNames.For).ToArray(), message.Extra);
return(new ValidationResult
{
MainReference = ConvertReference(composerResult.MainReference),
References = composerResult.References.Select(ConvertReference).ToList(),
Template = composerResult.Template,
Result = _messageSeverityProvider.GetLevel(message, checkModeDescriptor),
Rule = message.MessageType
});
}
catch (Exception ex)
{
throw new Exception($"Ошибка при сериализации сообщения {message.MessageType}", ex);
}
}
public IReadOnlyCollection <ValidationResult> GetValidationResult(IReadOnlyCollection <Version.ValidationResult> validationResults, ICheckModeDescriptor checkModeDescriptor)
{
var messages = validationResults.Select(ToMessage).ToList();
var resolvedNames = _nameResolvingService.Resolve(messages);
var result = MakeDistinct(messages).Select(x => Compose(x, resolvedNames, checkModeDescriptor)).ToList();
return(result);
}
private static DateTime GetValidationPeriodStart(IQuery query, long orderId, ICheckModeDescriptor checkModeDescriptor)
{
var order = query.For <Order>().Single(x => x.Id == orderId);
return(checkModeDescriptor.GetValidationPeriodStart(order));
}
public SingleController(ValidationResultFactory factory, PipelineFactory pipelineFactory, CheckModeDescriptorFactory descriptorFactory)
{
_factory = factory;
_pipelineFactory = pipelineFactory;
_checkModeDescriptor = descriptorFactory.GetDescriptorFor(CheckMode.Single);
}