protected override void EvaluateInternal()
{
Context.Rules = new RulesBundle(Context, this);
var ruleResult = RulesEvaluator.Create()
.Eval(Context.Rules.TransportIdRequired)
.Evaluate();
MergeFromResult(ruleResult);
if (!ruleResult.IsSuccess)
{
return;
}
var repository = ServiceProvider.GetService <IRepository <Olma.Transport> >();
Context.Transport = repository.FindAll()
.Where(i => i.Id == Context.TransportId)
.Include(i => i.Bids)
.SingleOrDefault();
var transportNotFound = Context.Transport == null;
AddMessage(transportNotFound, ResourceName, new TransportNotFound());
var transportExist = !transportNotFound;
var requested = Context.Transport?.Status == Olma.TransportStatus.Requested;
var allocated = Context.Transport?.Status == Olma.TransportStatus.Allocated;
var invalid = transportExist && !(requested || allocated);
AddMessage(invalid, ResourceName, Message);
}
private static void RunProgram(string input)
{
try
{
if (input.ToLower() == "help")
{
PrintInstructions();
return;
}
WeatherType weatherType = GetWeatherTypeFromInputString(input);
Person person = new Person();
List <IGettingReadyCommand> commands = ParseCommands(input, person, weatherType);
IEnumerable <IGettingReadyRule> rules = rulesRepository.GetRules();
// Compose the rules evaluator to run through all rules for our commands
RulesEvaluator evaluator = new RulesEvaluator(rules);
// Compose the command processor by giving it our commands and the rules evaluator to use
// for processing the rules on each command
CommandProcessor commandProcessor = new CommandProcessor(commands, evaluator);
string output = commandProcessor.Process();
Console.WriteLine($"\n{output}\n");
Console.WriteLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
// {{TODO}}
var transportOffering = Context.TransportOffering;
var divisionIds = Context.DivisionIds;
if (transportOffering.WinningBid != null &&
!Context.DivisionIds.Contains(transportOffering.WinningBid.DivisionId))
{
transportOffering.WinningBid = null;
}
transportOffering.Bids =
transportOffering.Bids.Where(i =>
divisionIds.Contains(i.DivisionId))
.ToList();
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluator
.Eval(Context.Rules.CustomerDivisionAuthorization)
.Eval(Context.Rules.IssuerDivisionHasPostingAccount) // Soll auf alle fälle ein Fehler sein!
.Eval(Context.Rules.RecipientHasDefaultPostingAccount) // Für DEMO erst mal nur Warnung
.Eval(Context.Rules.DocumentType)
.Eval(Context.Rules.Voucher)
.Eval(Context.Rules.LocalizationLanguageValid)
.Eval(Context.Rules.PrintCountValid)
.Eval(Context.Rules.BlacklistTerms);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
// Falls ein verletzung der Blacklist Regel vorliegt dann entferne den allgemeinen RuleState für den ResourceName
CleanupRuleStateIfExists(BlacklistMessageId, ResourceName);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
var transportRepo = ServiceProvider.GetService <IRepository <Olma.Transport> >();
Context.Transport = transportRepo.FindAll()
// TODO handle security seperately as we are disabling query filters to get both demand / supply order
.IgnoreQueryFilters()
.Include(i => i.WinningBid)
.Include(i => i.OrderMatch)
.Include(i => i.OrderMatch.Demand).ThenInclude(i => i.Detail)
.Include(i => i.OrderMatch.Supply).ThenInclude(i => i.Detail)
.SingleOrDefault(i => i.Id == Context.TransportId);
// Assign rules to the Evaluator
rulesEvaluator.Eval(Context.Rules.Required);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
// No need to validate
var transportRepo = ServiceProvider.GetService <IRepository <Olma.Transport> >();
Context.Transport = transportRepo.FindAll()
.IgnoreQueryFilters()
.Include(i => i.WinningBid)
.Include(i => i.Bids)
.SingleOrDefault(i => i.Id == Context.TransportId);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Assign all values for Context
Context.ServiceProvider = ServiceProvider;
Context.Mapper = ServiceProvider.GetService <IMapper>();
Context.LmsOrderGroupRepo = ServiceProvider.GetService <IRepository <Olma.LmsOrder> >();
Context.OlmaLoadCarrierRepo = ServiceProvider.GetService <IRepository <Olma.LoadCarrier> >();
Context.AuthData = ServiceProvider.GetService <IAuthorizationDataService>();
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create();
// Assign rules to the Evaluator
rulesEvaluator
.Eval(Context.Rules.LongitudeValidRule)
.Eval(Context.Rules.LatitudeValidRule)
.Eval(Context.Rules.RadiusValidRule)
.Eval(Context.Rules.MinStackHighValidRule)
.Eval(Context.Rules.MaxStackHighValidRule);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluator
.Eval(Context.Rules.CustomerDivisionAuthorizationRule)
.Eval(Context.Rules.DigitalCodePristine)
.Eval(Context.Rules.TruckDriverNameRequired)
.Eval(Context.Rules.LicensePlateRequired)
.Eval(Context.Rules.LicensePlateCountryIdRequired)
.Eval(Context.Rules.PositionsValid)
.Eval(Context.Rules.MoreInformationValid)
.Eval(Context.Rules.BlacklistTerms);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
// Add all Message from ruleResult
MergeFromResult(ruleResult);
// Add Message if ruleResult is not success
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
// Falls ein verletzung der Blacklist Regel vorliegt dann entferne den allgemeinen RuleState für den ResourceName
CleanupRuleStateIfExists(BlacklistMessageId, ResourceName);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
Context.AuthData = ServiceProvider.GetService <IAuthorizationDataService>();
Context.Mapper = ServiceProvider.GetService <IMapper>();
Context.CustomerDivisionRepo = ServiceProvider.GetService <IRepository <Olma.CustomerDivision> >();
Context.CustomerPartnerRepo = ServiceProvider.GetService <IRepository <Olma.CustomerPartner> >();
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
// No need to validate
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
var query = Context.VoucherSearchQuery;
query = OrderingQuery(Context.VouchersSearchRequest, query);
var projectedQuery = query.ProjectTo <Contracts.Models.Voucher>(Context.Mapper.ConfigurationProvider);
var paginationResult = projectedQuery.ToPaginationResult(Context.VouchersSearchRequest);
Fetch(paginationResult);
Context.PaginationResult = paginationResult;
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Get DivisionIds
Context.DivisionIds = ServiceProvider
.GetService <IAuthorizationDataService>()
.GetDivisionIds()
.ToArray();
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluator
.Eval(Context.Rules.TransportValid)
.Eval(Context.Rules.ModifyTransportOffering)
.Eval(Context.Rules.MaskAddressIfNecessary);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
EvaluateRules(Imposter imposter,
HttpContext context,
Request request)
{
var response = RulesEvaluator.Evaluate(imposter,
request,
out Expression <Func <Request, bool> > matchedCondition);
return(response, matchedCondition);
}
/// <summary>
/// First Validate IRule. If the rule is success the execute the action of the command
/// </summary>
/// <returns></returns>
public async Task <IWrappedResponse> Execute()
{
// Evaluate the Rule when
var result = RulesEvaluator.Create().Eval(Rule).Evaluate();
#region Security via Interface -> IValidationWithAuthorizationAbility
if (Rule is IRuleWithAuthorizationSkill ruleWithAuthorizationSkill)
{
var rRule = ruleWithAuthorizationSkill.Authorization.ResourceRule;
if (!rRule.IsValid())
{
return(await Task.Factory.StartNew(() => new WrappedResponse()
{
ResultType = ResultType.NotFound,
Errors = new[] { string.Empty }
}));
}
var aRule = ruleWithAuthorizationSkill.Authorization.AuthorizationRule;
if (!aRule.IsValid())
{
return(await Task.Factory.StartNew(() => new WrappedResponse()
{
ResultType = ResultType.Forbidden,
Errors = new[] { string.Empty }
}));
}
}
if (Rule is IRuleWithRessourceSkill ruleWithRessourceSkill)
{
var rRule = ruleWithRessourceSkill.ResourceRule;
if (!rRule.IsValid())
{
return(await Task.Factory.StartNew(() => new WrappedResponse()
{
ResultType = ResultType.NotFound,
Errors = new[] { string.Empty }
}));
}
}
#endregion
// if when valid -> return result of then or return the wrapped RuleState of when
return(result.IsSuccess
? await Action(Rule)
: result.WrappedResponse <TResultOfThen>());
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluator.Eval(Context.Rules.PostingAccountBalanceRule)
.Eval(Context.Rules.PostingAccountConditionRule);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
var postingAccountsConditions =
Context.Rules.PostingAccountConditionRule.Context.PostingAccountsConditions;
var postingAccountsBalances = Context.Rules.PostingAccountBalanceRule.Context.PostingAccountsBalances;
Context.PostingAccountsResult = new List <Contracts.Models.PostingAccount>();
foreach (var postingAccount in Context.PostingAccounts)
{
postingAccount.PickupConditions = postingAccountsConditions.Where(c =>
c.RefLtmsAccountId == postingAccount.RefLtmsAccountId &&
c.Type == PostingAccountConditionType.Pickup).ToList();
postingAccount.DropoffConditions = postingAccountsConditions.Where(c =>
c.RefLtmsAccountId == postingAccount.RefLtmsAccountId &&
c.Type == PostingAccountConditionType.DropOff).ToList();
postingAccount.DemandConditions = postingAccountsConditions.Where(c =>
c.RefLtmsAccountId == postingAccount.RefLtmsAccountId &&
c.Type == PostingAccountConditionType.Demand).ToList();
postingAccount.SupplyConditions = postingAccountsConditions.Where(c =>
c.RefLtmsAccountId == postingAccount.RefLtmsAccountId &&
c.Type == PostingAccountConditionType.Supply).ToList();
postingAccount.TransferConditions = postingAccountsConditions.Where(c =>
c.RefLtmsAccountId == postingAccount.RefLtmsAccountId &&
c.Type == PostingAccountConditionType.Transfer).ToList();
postingAccount.VoucherConditions = postingAccountsConditions.Where(c =>
c.RefLtmsAccountId == postingAccount.RefLtmsAccountId &&
c.Type == PostingAccountConditionType.Voucher).ToList();
postingAccount.Balances = postingAccountsBalances[postingAccount.Id];
Context.PostingAccountsResult.Add(postingAccount);
}
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluator
.Eval(Context.Rules.BlacklistOther);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
Context.AuthData = ServiceProvider.GetService <IAuthorizationDataService>();
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluator
.Eval(Context.Rules.ExpressCodeAuthorizationRule);
//Check issuer
var customerIds = Context.AuthData.GetCustomerIds().ToList();
var divisionIds = Context.AuthData.GetDivisionIds().ToList();
if (customerIds.Count > 0 && Context.ExpressCode.IssuingCustomerId != null && !customerIds.Contains((int)Context.ExpressCode.IssuingCustomerId))
{
RuleState.Add(ResourceName, new RuleState(Context.ExpressCode)
{
RuleStateItems = { new DigitalCodeIssuingCustomerDoesNotMatch() }
});
}
if (divisionIds.Count > 0 && Context.ExpressCode.IssuingDivisionId != null && !divisionIds.Contains((int)Context.ExpressCode.IssuingDivisionId))
{
RuleState.Add(ResourceName, new RuleState(Context.ExpressCode)
{
RuleStateItems = { new DigitalCodeIssuingDivisionDoesNotMatch() }
});
}
if (Context.ExpressCode.ValidTo.HasValue && Context.ExpressCode.ValidTo < DateTime.Today)
{
RuleState.Add(ResourceName, new RuleState(Context.ExpressCode)
{
RuleStateItems = { new DigitalCodeExpired() }
});
}
//TODO: implement generic ExpiredRule
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
// No need to validate deeper
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
rulesEvaluator.Eval(Context.Rules.LoadCarrierReceiptResourceRule);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
protected override void EvaluateInternal()
{
Context.Rules = new RulesBundle(Context, this);
var rulesEvaluator = RulesEvaluator.Create().CheckAllRules();
rulesEvaluator.Eval(Context.Rules.CustomerDivisionAuthorizationRule)
.Eval(Context.Rules.LoadCarrierIdValidationRule)
.Eval(Context.Rules.NumberOfLoadsValidationRule)
.Eval(Context.Rules.LoadingLocationIdValidationRule)
.Eval(Context.Rules.BaseLoadCarrierValidationRule);
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
Context.Mapper = ServiceProvider.GetService <IMapper>();
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
// Not Things to validate
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
public void Evaluate_WhenRequestContentDoesNotExistsAndConditionIsDefinedForRequestContent_ReturnsInternalServerError()
{
string responseContent = "None of evaluators could create a response.";
var imposter = new ImposterDefinition("test")
.DeclareResource("/test", HttpMethod.Post)
.When(r => r.Content.Contains("none of the imposter conditions will be able to " +
"match this text"))
.Then(new DummyResponseCreator(responseContent, INTERNAL_SERVER_ERROR))
.Build();
var request = new RequestBuilder()
.Build();
var response = RulesEvaluator.Evaluate(imposter, request, out _);
response.StatusCode.Should().Be(INTERNAL_SERVER_ERROR);
response.Content.Should().Be(responseContent);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
// No need to validate
Context.TransportOfferingsPaginationResult = CreateTransportOfferingPaginationResult();
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluator
.Eval(Context.Rules.CustomerDivisionAuthorizationRule)
.Eval(Context.Rules.OrderSearchQueryRule)
.Eval(Context.Rules.OrderSummaryValidRule);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
public void Evaluate_WhenRequestContentMatchesTheCondition_ReturnsPreDefinedResponse()
{
string requestContent = "dummy request";
string responseContent = "dummy response.";
var imposter = new ImposterDefinition("test")
.DeclareResource("/test", HttpMethod.Post)
.When(r => r.Content.Contains(requestContent))
.Then(new DummyResponseCreator(responseContent, STATUS_CODE_OK))
.Build();
var request = new RequestBuilder()
.WithRequestContent(requestContent)
.Build();
var response = RulesEvaluator.Evaluate(imposter, request, out _);
response.StatusCode.Should().Be(STATUS_CODE_OK);
response.Content.Should().Be(responseContent);
}
public override void Evaluate()
{
var result = RulesEvaluator.Create()
.Eval(new OrderGroupHasOrdersRule(OrderGroup))
.Eval(new OrderGroupHasOpenOrConfirmedOrdersRule(OrderGroup))
.Evaluate();
if (!result.IsSuccess)
{
RuleState.Add("OrderGroup", new RuleState(OrderGroup)
{
RuleStateItems = { new OrderGroupCancel() }
});
}
if (result is RuleWithStateResult stateResult)
{
RuleState.Merge(stateResult.State);
}
}
protected override void EvaluateInternal()
{
Context.Rules = new RulesBundle(Context, this);
var ruleResult = RulesEvaluator.Create()
.Eval(Context.Rules.RequiredSourceAccountIdRule)
.Evaluate();
MergeFromResult(ruleResult);
if (!ruleResult.IsSuccess)
{
return;
}
var postingAccountRepository = ServiceProvider.GetService <IRepository <Olma.PostingAccount> >();
Context.SourceAccount = postingAccountRepository.GetByKey(Context.SourceAccountId);
AddMessage(Context.SourceAccount == null, ResourceName, Message);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
var repository = ServiceProvider.GetService <IRepository <Olma.Transport> >();
Context.TransportOffering = repository.GetById <Olma.Transport, TransportOffering>(Context.TransportId, true).Data;
// Assign rules to the Evaluator
rulesEvaluator.Eval(Context.Rules.Required);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
Context.ExpressCodeRepository = ServiceProvider.GetService <IRepository <Olma.ExpressCode> >();
Context.ExpressCodeUsageConditionRepository = ServiceProvider.GetService <IRepository <Olma.ExpressCodeUsageCondition> >();
Context.Mapper = ServiceProvider.GetService <IMapper>();
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
// Not things to validate
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
Context.ExpressCode = Context.ExpressCodeResult;
if (Context.ExpressCode == null)
{
RuleState.Add(ResourceName, new RuleState(Context.ExpressCode)
{
RuleStateItems = { new DigitalCodeInvalid() }
});
}
else
{
if (Context.Parent.PrintType == PrintType.LoadCarrierReceiptDelivery &&
(Context.ExpressCodeUsageCondition == null || !Context.ExpressCodeUsageCondition.AcceptForDropOff))
{
RuleState.Add(ResourceName, new RuleState(Context.ExpressCodeUsageCondition)
{
RuleStateItems = { new ReceivingUnplannedDeliveriesNotAllowed() }
});
}
}
MergeFromResult(ruleResult);
}
public void Evaluate_WhenRequestHeaderDoesNotExistsAndConditionIsDefinedForRequestHeader_ReturnsInternalServerError()
{
string responseContent = "None of evaluators could create a response.";
var imposter = new ImposterDefinition("test")
.DeclareResource("/test", HttpMethod.Post)
.When(r => r.RequestHeader.ContainsKeyAndValues("Accept", new []
{
"text/plain",
"test/xml"
}))
.Then(new DummyResponseCreator(responseContent, INTERNAL_SERVER_ERROR))
.Build();
var request = new RequestBuilder()
.Build();
var response = RulesEvaluator.Evaluate(imposter, request, out _);
response.StatusCode.Should().Be(INTERNAL_SERVER_ERROR);
response.Content.Should().Be(responseContent);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
// No need to validate deeper
var dbContext = ServiceProvider.GetService <OlmaDbContext>();
var exists = dbContext.LocalizationLanguages.Count(l => l.Id == Context.LocalizationId) > 0;
AddMessage(!exists, ResourceName, Message);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
/// <summary>
/// Internal Method for Evaluate
/// </summary>
protected override void EvaluateInternal()
{
// Initialized all rules. Instancing only takes place during execution, since otherwise the service scope has not yet been assigned
Context.Rules = new RulesBundle(Context, this);
// Initialized Evaluator
var rulesEvaluator = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluator
.Eval(Context.Rules.CustomerNameRequiredRule)
.Eval(Context.Rules.PartnerDirectoryResourceRule)
.Eval(Context.Rules.BlacklistTermsRule);
// Evaluate
var ruleResult = rulesEvaluator.Evaluate();
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
// Falls ein verletzung der Blacklist Regel vorliegt dann entferne den allgemeinen RuleState für den ResourceName
CleanupRuleStateIfExists(BlacklistMessageId, ResourceName);
}
