protected virtual List <Rule> EvaluateAllRules(Dictionary <string, object> dataDictionary)
{
if (Conditions.Any(c => !c.EvaluateCondition(dataDictionary)))
{
return(null);
}
List <Rule> rulesMet = new List <Rule>();
rulesMet = EvaluateSubRules(dataDictionary);
if (ReturnSelf)
{
rulesMet.Add(this);
}
if ((RuleEvaluationFlags & RuleEvaluationFlags.UsePriority) == RuleEvaluationFlags.UsePriority)
{
HighestPriority(ref rulesMet);
}
if ((RuleEvaluationFlags & RuleEvaluationFlags.UseWeight) == RuleEvaluationFlags.UseWeight)
{
HighestWeight(ref rulesMet);
}
if (rulesMet.Count > 0)
{
return(rulesMet);
}
else
{
return(null);
}
}
public override string ToString()
{
var str1 = Conditions.Any() ? "\n" + string.Join("\n", Conditions) : string.Empty;
var str2 = "[" + RightAlias + "]";
return(string.Format("{0} [{1}].[{2}]{3}{4}", (object)SpecificationType, (object)RightSchema, (object)RightTable, string.IsNullOrWhiteSpace(RightAlias) ? (object)string.Empty : (object)(" AS [" + str2 + "]"), (object)str1));
}
public int MaxClauseOrder()
{
if (!Conditions.Any())
{
return(0);
}
return(Conditions.Max(qc => qc.Order));
}
public override bool Eval([NotNull] PlayerInfo info)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
return(Conditions == null || Conditions.Any(t => t.Eval(info)));
}
protected void AddQuantity(int amount = 1)
{
if (Conditions.Any(c => !c.Check()))
{
return;
}
ChangeQuantity(Quantity + amount);
}
public override bool IsTrue(DateTime Value)
{
var ret = true;
if (Conditions.Count > 0)
{
ret = Conditions.Any(x => x.IsTrue(Value));
}
return(ret);
}
public void FilterQuery <T>(ref IEnumerable <T> enumerable)
{
if (string.IsNullOrEmpty(Column) && !Conditions.Any())
{
return;
}
enumerable = enumerable.AsQueryable().Where(WhereCondition.Item1, WhereCondition.Item2);
_argumentNumber = 0;
}
public void ValidateChildren()
{
if (Conditions.Any(c => c.IsValid == false) || IsValid == false)
{
AreChildrenValid = false;
}
else
{
AreChildrenValid = true;
}
}
internal string ToBodyConditions()
{
var body = new CWConditionBody
{
Conditions = Conditions != null && Conditions.Any() ? and(Conditions) : null,
ChildConditions = ChildConditions != null && ChildConditions.Any() ? and(ChildConditions) : null,
CustomFieldConditions = CustomFieldConditions != null && CustomFieldConditions.Any() ? and(CustomFieldConditions) : null,
OrderBy = !string.IsNullOrWhiteSpace(OrderBy) ? OrderBy : null
};
return(JsonConvert.SerializeObject(body));
}
/// <summary>
/// 文字列取得
/// </summary>
/// <param name="index">前スペース数</param>
/// <returns>文字列</returns>
public override string ToString(int index = 0)
{
var result = new StringBuilder();
var indexSpace = string.Concat(Enumerable.Repeat(" ", index));
foreach (var comment in Comments)
{
result.Append(indexSpace);
result.AppendLine($"{comment}");
}
result.Append(indexSpace);
if (Conditions.Any())
{
result.Append("else if(");
for (var i = 0; i < Conditions.Count; i++)
{
var isSetSpace = true;
if (i == Conditions.Count - 1)
{
isSetSpace = false;
}
else if (Conditions[i].Name == "." || Conditions[i + 1].Name == ".")
{
isSetSpace = false;
}
result.Append($"{Conditions[i].Name}");
if (isSetSpace)
{
result.Append(" ");
}
}
result.AppendLine(")");
}
else
{
result.AppendLine("else");
}
result.Append(indexSpace);
result.AppendLine("{");
foreach (var statement in Block)
{
result.AppendLine(statement.ToString(index + 1));
}
result.Append(indexSpace);
result.AppendLine("}");
return(result.ToString());
}
public bool MeetsFilter(IRecord record)
{
var result = true;
if (ConditionOperator == FilterOperator.Or)
{
result =
(!Conditions.Any() && !SubFilters.Any()) ||
Conditions.Any(c => c.MeetsCondition(record)) ||
SubFilters.Any(f => f.MeetsFilter(record));
}
else
{
result = Conditions.All(c => c.MeetsCondition(record)) &&
SubFilters.All(f => f.MeetsFilter(record));
}
return(result);
}
public bool IsActive(IStatisticsWriter writer, IToggleContext context)
{
var stats = new Statistic
{
ToggleID = ID,
Timestamp = DateTime.Now,
User = context.GetCurrentUser()
};
var isActive = ConditionMode == ConditionModes.Any
? Conditions.Any(c => c.IsMatch(stats, context))
: Conditions.All(c => c.IsMatch(stats, context));
stats.Active = isActive;
writer.Write(stats);
return(isActive);
}
public virtual Rule EvaluateRules(Dictionary <string, object> dataDictionary, RuleEvaluationFlags ruleFlags)
{
if (Conditions.Any(c => !c.EvaluateCondition(dataDictionary)))
{
return(null);
}
List <Rule> rulesMet = new List <Rule>();
rulesMet = EvaluateSubRules(dataDictionary);
if (ReturnSelf)
{
rulesMet.Add(this);
}
if ((ruleFlags & RuleEvaluationFlags.UsePriority) == RuleEvaluationFlags.UsePriority)
{
HighestPriority(ref rulesMet);
}
if ((ruleFlags & RuleEvaluationFlags.UseWeight) == RuleEvaluationFlags.UseWeight)
{
HighestWeight(ref rulesMet);
}
if (rulesMet.Count > 0)
{
if ((ruleFlags & RuleEvaluationFlags.ReturnRandom) == RuleEvaluationFlags.ReturnRandom)
{
return(RandomRule(ref rulesMet));
}
else
{
return(rulesMet[0]);
}
}
else
{
return(null);
}
}
/// <summary>
/// Returns true if all conditions are passing
/// Returns true if there are no conditions
/// Returns false if any condition is failing
/// Returns false if any variable does not exist
/// Returns false if there is an exception of any kind
/// </summary>
private bool Passing(int update)
{
if (!Conditions.Any())
{
if (_dataObject.IsDebugMode())
{
var debugItemStaticDataParams = new DebugItemStaticDataParams(nameof(Passing), "", true);
AddDebugOutputItem(debugItemStaticDataParams);
}
return(true);
}
try
{
var res = Conditions.Select(a => a.Eval(GetArgumentsFunc, _dataObject.Environment.HasErrors()));
return(res.All(o => o));
}
catch (Exception e)
{
Dev2Logger.Warn("failed checking passing state of gate", e, _dataObject?.ExecutionID?.ToString());
return(false);
}
}
void IRule <PromotionCart> .Initialize(PromotionCart promotionCart)
{
int cartValue = 0;
if (validateCart(promotionCart))
{
return;
}
foreach (var promotionRule in _promtionRules)
{
bool validate = Conditions.Any(o => o.SKUid.Contains(promotionRule.SKUids) && o.CondnPassed());
if (validate)
{
continue;
}
switch (promotionRule.PromotionType)
{
case PromotionType.ItemCount:
cartValue = promotionCart.Products.Where(o => o.SKUId == promotionRule.SKUids).Count();
Conditions.Add(new CountPromo(cartValue, promotionRule));
break;
case PromotionType.Combo:
var purchaselist = promotionCart.Products.Select(o => o.SKUId).ToArray();
Conditions.Add(new ComboPromo(purchaselist, promotionRule));
break;
case PromotionType.Percentage:
cartValue = promotionCart.Products.Where(o => o.SKUId == promotionRule.SKUids).Count();
decimal cartPrice = promotionCart.Products.Where(o => o.SKUId == promotionRule.SKUids).Sum(o => o.Price);
Conditions.Add(new PercentagePromo(cartValue, cartPrice, promotionRule));
break;
default: break;
}
}
}
public HttpCheck(
long id,
Environment environment,
Service service,
TimeSpan interval,
Uri url,
IReadOnlyCollection <HttpCheckCondition> conditions,
HttpMethod method,
TimeSpan?connectTimeout = null,
TimeSpan?readTimeout = null,
int maxContentLength = DefaultMaxContentLength) : base(id, environment, service, interval, conditions)
{
if (method == default(HttpMethod))
{
throw new ArgumentOutOfRangeException(nameof(method));
}
if (interval <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(interval));
}
if (maxContentLength <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maxContentLength));
}
Url = url ?? throw new ArgumentNullException(nameof(url));
Method = method;
ConnectTimeout = connectTimeout ?? DefaultConnectTimeout;
ReadTimeout = readTimeout ?? DefaultReadTimeout;
MaxContentLength = maxContentLength;
if (Conditions.Any(c => c == null))
{
throw new ArgumentException("conditions contains a null");
}
}
public bool AreConditionsVerified(T input)
{
Conditions.ForEach(i => i.Validate(input));
return(!Conditions.Any(c => c.ValidationErrors.Any()));
}
public override bool IsMatch(UIApplication uiApp, CategorySet selectedCategories)
{
bool res = Conditions.Any(c => c.IsMatch(uiApp, selectedCategories));
return(IsNot ? !res : res);
}
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
var methodKeyName = binder.Name;
var baseMethod = BaseType.GetMethod(binder.Name);
result = null;
//Do we meet all the conditions outlined for this method
if (Conditions.Any(cond => cond.Item1.Equals(methodKeyName)))
{
var method = BaseType.GetMethods().First(m => m.Name.Equals(methodKeyName));
if (method != null)
{
var parameters = method.GetParameters();
int metConditions = 0;
for (int i = 0; i < parameters.Count(); i++)
{
var argument = parameters.ElementAt(i);
var value = args[i];
foreach (var condition in Conditions.Where(cond => cond.Item1.Equals(methodKeyName) && cond.Item2.Equals(argument.Name, StringComparison.OrdinalIgnoreCase)))
{
if (condition.Item3(value))
{
metConditions++;
}
}
}
if (metConditions.Equals(Conditions.Count(cond => cond.Item1.Equals(methodKeyName))))
{
//We have a match
methodKeyName = string.Format("{0}_{1}", binder.Name, Serialization.GenerateHashKey(Conditions.Where(cond => cond.Item1.Equals(methodKeyName)).ToArray()));
}
}
}
//Do we want to throw an error?
if (ExpectedErrors.Any(x => methodKeyName.Equals(x.Item1)))
{
Exception instance = (Exception)Activator.CreateInstance(ExpectedErrors.First(x => methodKeyName.Equals(x.Item1)).Item2);
throw instance;
}
//Do we exist in the list of naked or conditional-hash-appended methods
if (MockedMembers.ContainsKey(methodKeyName) && MockedMembers[methodKeyName] is Delegate)
{
Delegate del = MockedMembers[methodKeyName] as Delegate;
result = del.DynamicInvoke();
//Try and set out parameters
if (OutParameters.ContainsKey(methodKeyName) && baseMethod.GetParameters().Any(param => param.IsOut))
{
var outValues = OutParameters[methodKeyName];
int i = -1;
foreach (var param in baseMethod.GetParameters())
{
i++;
if (!param.IsOut || !outValues.ContainsKey(param.Name))
{
continue;
}
args[i] = (object)outValues[param.Name];
}
}
return(true);
}
//We don't exist in the list at all just try to call the base method
return(base.TryInvokeMember(binder, args, out result));
}
/// <summary>
/// Check if filter has any condition of a specific type.
/// </summary>
/// <param name="condition_guid">The condition type to check.</param>
/// <returns>True if the filter has a condition of the specified type.</returns>
public bool HasCondition(Guid condition_guid)
{
return(Conditions.Any(c => c.FieldKey == condition_guid));
}
void IJsonSerializable.Serialize(JsonWriter writer)
{
// Types
if (Types != null && Types.Any())
{
writer.WritePropertyName("types");
writer.WriteStartObject();
foreach (var type in Types)
{
writer.WritePropertyName(type);
writer.WriteRawValue(GetTypeJson(type));
}
writer.WriteEndObject();
}
if (Instances != null && Instances.Any())
{
writer.WritePropertyName("instances");
writer.WriteStartObject();
foreach (var typeItem in Instances)
{
writer.WritePropertyName(typeItem.Key);
writer.WriteStartObject();
// Serialize static property values
if (typeItem.Value.StaticProperties.Count > 0)
{
writer.WritePropertyName("static");
writer.Serialize(
typeItem.Value.StaticProperties.ToDictionary(
property => property.Name,
property => JsonConverter.GetPropertyValue(property, property.DeclaringType)));
}
// Serialize instances
foreach (var instanceItem in typeItem.Value.Instances)
{
writer.WritePropertyName(instanceItem.Key);
writer.Serialize(instanceItem.Value);
}
writer.WriteEndObject();
}
writer.WriteEndObject();
}
if (Conditions != null && Conditions.Any())
{
writer.WritePropertyName("conditions");
writer.Serialize(Conditions);
}
if (Events != null && Events.Any())
{
writer.WritePropertyName("events");
writer.Serialize(Events);
}
if (Model != null && Model.Any())
{
writer.WritePropertyName("model");
writer.Serialize(Model);
}
if (ServerInfo != null)
{
writer.WritePropertyName("serverInfo");
writer.Serialize(ServerInfo);
}
if (Changes != null && Changes.Any())
{
writer.WritePropertyName("changes");
writer.Serialize(Changes.Where(modelEvent => !(modelEvent is ModelValueChangeEvent) || ExoWeb.IncludeInClientModel(((ModelValueChangeEvent)modelEvent).Property)));
}
}
public override bool EvalCondition(IDmlfNamespace ns)
{
return(Conditions.Any(x => x.EvalCondition(ns)));
}
public override bool Match(FilterableObjectData obj) => Conditions.Any(x => x.Match(obj));
private string BuildWhere()
{
if (BlackList.Contains(Conditions.SelectMany(condition => condition.Field)))
{
throw new Exception($"'Field' contains blacklist word.");
}
if (BlackList.Contains(Conditions.SelectMany(condition => condition.Value)))
{
throw new Exception($"'Value' contains blacklist word.");
}
var where = new List <string>();
if (Conditions.Any())
{
foreach (var condition in Conditions)
{
switch (condition.Operator)
{
case Operator.Equals:
where.Add($"[{condition.Field}] = @{condition.Field}");
Parameters.Add(condition.Field, condition.Value);
break;
case Operator.Like:
where.Add($"[{condition.Field}] LIKE '%@{condition.Field}%'");
Parameters.Add(condition.Field, condition.Value);
break;
case Operator.LessThan:
where.Add($"[{condition.Field}] < @{condition.Field}");
Parameters.Add(condition.Field, condition.Value);
break;
case Operator.LessThanOrEqual:
where.Add($"[{condition.Field}] <= @{condition.Field}");
Parameters.Add(condition.Field, condition.Value);
break;
case Operator.GreaterThan:
where.Add($"[{condition.Field}] > @{condition.Field}");
Parameters.Add(condition.Field, condition.Value);
break;
case Operator.GreaterThanOrEqual:
where.Add($"[{condition.Field}] >= @{condition.Field}");
Parameters.Add(condition.Field, condition.Value);
break;
case Operator.Between:
where.Add($"[{condition.Field}] BETWEEN @{@condition.Field}_LEFT AND @{condition.Field}_RIGHT");
Parameters.Add($"{condition.Field}_LEFT", condition.Left);
Parameters.Add($"{condition.Field}_RIGHT", condition.Right);
break;
case Operator.Near:
where.Add($"[{condition.Field}].STDistance('POINT({condition.Latitude.ToString(Format)} {condition.Longitude.ToString(Format)})') IS NOT NULL");
where.Add($"[{condition.Field}].STDistance('POINT({condition.Latitude.ToString(Format)} {condition.Longitude.ToString(Format)})') < {condition.Radio}");
break;
default:
throw new ArgumentOutOfRangeException(nameof(condition.Operator), condition.Operator, null);
}
}
}
return(!where.Any()
? string.Empty
: $"WHERE {string.Join(" AND ", @where)}");
}
internal bool HasCondition(Condition.Type type)
{
return(Conditions.Any(c => c.Name == type));
}
protected override bool InputValidates()
{
return(Conditions.Any(c => c.Validates()));
}
public bool HasCondition(string condition)
{
return(Conditions.Any(c => c.Name == condition));
}
public bool Call(GameContext context)
{
return(Conditions.Any(c => c.Call(context)));
}
internal void AddConditions(DicModel dic)
{
if (!string.IsNullOrWhiteSpace(dic.CsValue) &&
dic.CsValue.Contains(",") &&
dic.Option == OptionEnum.In)
{
var vals = dic.CsValue.Split(',').Select(it => it);
var i = 0;
foreach (var val in vals)
{
//
i++;
var op = OptionEnum.None;
if (i == 1)
{
op = OptionEnum.In;
}
else
{
op = OptionEnum.InHelper;
}
//
var dicx = new DicModel
{
TableOne = dic.TableOne,
ClassFullName = dic.ClassFullName,
ColumnOne = dic.ColumnOne,
TableAliasOne = dic.TableAliasOne,
TableTwo = dic.TableTwo,
KeyTwo = dic.KeyTwo,
AliasTwo = dic.AliasTwo,
Param = dic.Param,
ParamRaw = dic.ParamRaw,
CsValue = val,
ValueType = dic.ValueType,
ColumnType = dic.ColumnType,
Option = op,
Action = dic.Action,
Crud = dic.Crud,
Compare = dic.Compare,
TvpIndex = dic.TvpIndex
};
AddConditions(dicx);
}
Conditions.Remove(dic);
}
else if (!string.IsNullOrWhiteSpace(dic.Param) &&
Conditions.Any(it => dic.Param.Equals(it.Param, StringComparison.OrdinalIgnoreCase)))
{
if (dic.Param.Contains("__"))
{
var arr = dic.Param.Split(new string[] { "__" }, StringSplitOptions.RemoveEmptyEntries);
var val = Convert.ToInt32(arr[arr.Length - 1]);
val++;
dic.Param = dic.ParamRaw + "__" + val.ToString();
}
else
{
dic.Param += "__1";
}
AddConditions(dic);
}
else
{
Conditions.Add(dic);
}
}