/// <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.PostingAccountRepository = ServiceProvider.GetService <IRepository <Olma.PostingAccount> >();
Context.LoadCarrierRepository = ServiceProvider.GetService <IRepository <Olma.LoadCarrier> >();
Context.LmsAvail2deliRepository = ServiceProvider.GetService <IRepository <LmsAvail2deli> >();
Context.LmsQuali2palletRepository = ServiceProvider.GetService <IRepository <LmsQuali2pallet> >();
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() }
});
}
AddMessage(!ruleResult.IsSuccess, ResourceName, Message);
MergeFromResult(ruleResult);
}
protected override void EvaluateInternal()
{
if (Context.ExpressCode == null || Context.ExpressCode.IsCanceled)
{
RuleState.Add(ResourceName, new RuleState(Context.ExpressCode)
{
RuleStateItems = { Message }
});
}
}
protected override void EvaluateInternal()
{
if (Context.Parent.OrderGroupsCreateRequest.QuantityType == OrderQuantityType.Load &&
(Context.Parent.OrderGroupsCreateRequest.NumberOfLoads < MinNumberOfLoads ||
Context.Parent.OrderGroupsCreateRequest.NumberOfLoads > MaxNumberOfLoads))
{
RuleState.Add(ResourceName, new RuleState {
RuleStateItems = { Message }
});
}
}
private void AddMixedMode()
{
if (!RuleState.Contains(mixedModeTuple))
{
var image = PresentationResourceService.GetBitmapSource("Icons.16x16.ClosedFolderBitmap");
mixedModeTuple = Tuple.Create <ImageSource, string>(image,
StringParser.Parse("${res:ICSharpCode.CodeAnalysis.ProjectOptions.WarningErrorMixed}"));
RuleState.Add(mixedModeTuple);
Index = RuleState.Count - 1;
base.RaisePropertyChanged("Index");
}
}
public override void Evaluate()
{
var invalidState = OrderGroup.Orders == null || OrderGroup.Orders.Count == 0;
if (invalidState)
{
RuleState.Add("OrderGroup", new RuleState(OrderGroup)
{
RuleStateItems = { new OrderGroupHasOrders() }
});
}
}
protected override void EvaluateInternal()
{
if (Context.LoadCarrierId == 0)
{
RuleState.Add(ResourceName, new RuleState {
RuleStateItems = { new LoadCarrierRequired() }
});
return;
}
var loadCarrierRepository = ServiceProvider.GetService <IRepository <Olma.LoadCarrier> >();
var loadCarrierExists = loadCarrierRepository.FindAll().Any(lc => lc.Id == Context.LoadCarrierId);
AddMessage(!loadCarrierExists, 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);
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);
}
protected override void EvaluateInternal()
{
if (Context.PostingAccountId == 0)
{
RuleState.Add(ResourceName, new RuleState {
RuleStateItems = { new PostingAccountRequired() }
});
return;
}
var postingAccountRepository = ServiceProvider.GetService <IRepository <Olma.PostingAccount> >();
var postingAccountExists = postingAccountRepository.FindAll()
.Any(pa => pa.Id == Context.PostingAccountId);
AddMessage(!postingAccountExists, 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);
var loadCarrierRepository = ServiceProvider.GetService <IRepository <Olma.LoadCarrier> >();
Olma.LoadCarrier loadCarrier = loadCarrierRepository
.FindByCondition(lc => lc.Id == Context.Request.LoadCarrierId)
.Include(lct => lct.Type).ThenInclude(blc => blc.BaseLoadCarrierMappings).FirstOrDefault();
if (loadCarrier == null)
{
return;
}
switch (loadCarrier.Type.BaseLoadCarrier)
{
case BaseLoadCarrierInfo.None when Context.Request.BaseLoadCarrierId != null:
RuleState.Add(ResourceName, new RuleState {
RuleStateItems = { Message }
});
break;
case BaseLoadCarrierInfo.Required when Context.Request.BaseLoadCarrierId == null:
RuleState.Add(ResourceName, new RuleState {
RuleStateItems = { new BaseLoadCarrierRequired() }
});
break;
default:
{
if (loadCarrier.Type.BaseLoadCarrier != BaseLoadCarrierInfo.None &&
Context.Request.BaseLoadCarrierId != null && loadCarrier.Type.BaseLoadCarrierMappings.All(blc =>
blc.LoadCarrierId != Context.Request.BaseLoadCarrierId))
{
RuleState.Add(ResourceName, new RuleState {
RuleStateItems = { new BaseLoadCarrierError() }
});
}
break;
}
}
}
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()
{
switch (Context.LoadingLocationId)
{
case null:
return;
case 0:
RuleState.Add(ResourceName, new RuleState {
RuleStateItems = { new LoadingLocationRequired() }
});
return;
}
var loadingLocationRepository = ServiceProvider.GetService <IRepository <Olma.LoadingLocation> >();
var loadingLocationExists = loadingLocationRepository.FindAll()
.Any(location => location.Id == Context.LoadingLocationId);
AddMessage(!loadingLocationExists, ResourceName, Message);
}
public override void Evaluate()
{
// No statement for an empty quantity
if (OrderGroup.Orders == null)
{
return;
}
var validState = OrderGroup.Orders.Any(og =>
og.Status == Dpl.B2b.Common.Enumerations.OrderStatus.Pending ||
og.Status == Dpl.B2b.Common.Enumerations.OrderStatus.Confirmed);
if (!validState)
{
RuleState.Add("OrderGroup",
new RuleState(OrderGroup)
{
RuleStateItems = { new OrderGroupHasOpenOrConfirmedOrders() }
});
}
}
/// <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);
}
/// <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 rulesEvaluatorExpressCode = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluatorExpressCode
// .Eval(Context.Rules.CustomerDivisionAuthorizationRule)
.Eval(Context.Rules.ExpressCodeValidRule);
// Evaluate
var ruleResult = rulesEvaluatorExpressCode.Evaluate();
if (ruleResult.IsSuccess)
{
Context.DigitalCode = Context.Rules.ExpressCodeValidRule.Context.ExpressCode;
var partnerExpressCodeCondition = Context.Rules.ExpressCodeValidRule.Context.OlmaRecipientPartner
.DefaultPostingAccount.ExpressCodeCondition;
if (Context.DigitalCode?.IsCanceled ?? false)
{
RuleState.Add(ResourceName, new RuleState(Context.DigitalCode)
{
RuleStateItems = { new DigitalCodeCanceled() }
});
}
if (Context.DigitalCode?.ValidTo < DateTime.Now)
{
RuleState.Add(ResourceName, new RuleState(Context.DigitalCode)
{
RuleStateItems = { new DigitalCodeExpired() }
});
}
if (Context.PrintType == PrintType.LoadCarrierReceiptDelivery && !partnerExpressCodeCondition.AllowDropOff ||
Context.PrintType == PrintType.VoucherCommon && !partnerExpressCodeCondition.AllowReceivingVoucher)
{
RuleState.Add(ResourceName, new RuleState(Context.DigitalCode)
{
RuleStateItems = { new DigitalCodeInvalid() }
});
}
}
else
{
var rulesEvaluatorExpressCodeFromOderLoad = RulesEvaluator.Create().StopEvaluateOnFirstInvalidRule();
// Assign rules to the Evaluator
rulesEvaluatorExpressCodeFromOderLoad
.Eval(Context.Rules.OrderLoadValidRule);
// Evaluate
ruleResult = rulesEvaluatorExpressCodeFromOderLoad.Evaluate();
if (ruleResult.IsSuccess)
{
Context.DigitalCode = Context.Rules.OrderLoadValidRule.Context.ExpressCode;
}
}
MergeFromResult(ruleResult);
}
