/// <summary>
/// 添加含有括号的条件
/// </summary>
/// <param name="relationType">关联运算符</param>
/// <param name="condition">条件生成器</param>
public virtual IConditionBuilder Block(RelationType relationType, IConditionBuilder condition)
{
if (condition == null)
{
return(this);
}
var conditionBuilder = condition as ConditionBuilder;
if (conditionBuilder == null || conditionBuilder.ConditionAppendBuilder.ToString().Trim().Length < 6)
{
return(this);
}
if (!ConditionAppendBuilder.ToString().Trim()
.EndsWith("WHERE", StringComparison.InvariantCultureIgnoreCase))
{
this.ConditionAppendBuilder.Append(GetRelation(relationType));
}
this.ConditionAppendBuilder.AppendFormat(" ({0}) ",
conditionBuilder.ConditionAppendBuilder.ToString().Remove(0, 6));
if (conditionBuilder.ParamDictionary.Count > 0)
{
this.ParamDictionary.AddRange(conditionBuilder.ParamDictionary, true);
}
this.Length++;
return(this);
}
private StatBuilderAdapter(
IStatBuilder statBuilder, IConditionBuilder conditionBuilder, Func <IStat, IStat> statConverter)
{
_statBuilder = statBuilder;
_conditionBuilder = conditionBuilder;
_statConverter = statConverter;
}
public IThenBuilder If(IConditionBuilder condition)
{
IThenBuilder Resolve(ResolveContext context) =>
new ThenBuilder($"if ({condition.Resolve(context)})", (current, _) => current);
return(new ThenBuilder($"if ({condition})", (_, context) => Resolve(context)));
}
public static T Condition <T>(this T builder, IConditionBuilder b)
where T : IConditionBuilderHolder
{
builder.ConditionBuilder = b;
return(builder);
}
private string GetWhereConditionsForDataModel(DbContextAction contextAction, object dataModel)
{
var conditionCount = 0;
var tableName = dataModel.GetThuriaDataModelTableName();
var dataModelConditions = dataModel.GetThuriaDataModelConditions(contextAction);
string whereCondition;
lock (_conditionBuilderLock)
{
_conditionBuilder.Clear();
foreach (var currentCondition in dataModelConditions)
{
var propertyValue = currentCondition.Value;
if (propertyValue == null || propertyValue.Equals(propertyValue.GetType().GetDefaultData()))
{
continue;
}
if (conditionCount > 0)
{
_conditionBuilder = _conditionBuilder.WithAnd();
}
_conditionBuilder = _conditionBuilder.WithCondition(tableName, currentCondition.ColumnName, EqualityOperators.Equals, propertyValue);
conditionCount++;
}
whereCondition = _conditionBuilder.Build();
}
return(whereCondition);
}
public void Add([RegexPattern] string regex, T stat, IConditionBuilder condition)
{
var builder = ModifierBuilder
.WithStat(stat)
.WithCondition(condition);
Add(regex, builder);
}
public IntermediateModifierEntry WithCondition(IConditionBuilder condition)
{
if (Condition != null && condition != null)
{
throw new InvalidOperationException(nameof(WithCondition) + " must not be called multiple times");
}
return(new IntermediateModifierEntry(Form, Stat, Value, condition));
}
/// <summary>
/// 添加Sql语句条件，默认Or连接，允许你写任何不支持上面的方法，所有它会给你最大的灵活性
/// </summary>
/// <param name="builder">生成器</param>
/// <param name="sql">Sql语句</param>
/// <param name="appendCondition">是否拼接条件</param>
/// <returns></returns>
public static IConditionBuilder OrAppendRaw(this IConditionBuilder builder, string sql, bool appendCondition)
{
if (appendCondition)
{
builder.AppendRaw(RelationType.Or, sql);
}
return(builder);
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Creates a new TerminatingCondition.
/// </summary>
/// <param name="last">The last condition builder in the condition chain.</param>
/// <param name="predicate">A predicate delegate that determines the result of the condition.</param>
public TerminatingCondition(IConditionBuilder <TRoot, TSubject> last, Predicate <TSubject> predicate)
{
Ensure.ArgumentNotNull(last, "last");
Ensure.ArgumentNotNull(predicate, "predicate");
_previous = last;
_predicate = predicate;
}
private IntermediateModifierEntry(IFormBuilder form, IStatBuilder stat, IValueBuilder value,
IConditionBuilder condition)
{
Form = form;
Stat = stat;
Value = value;
Condition = condition;
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Creates a new ConditionBuilderBase.
/// </summary>
/// <param name="last">The previous builder in the conditional chain.</param>
/// <param name="converter">A step converter delegate that translates from the previous step's output to this builder's subject.</param>
protected ConditionBuilderBase(IConditionBuilder <TRoot, TPrevious> last, Func <TPrevious, TSubject> converter)
{
Ensure.ArgumentNotNull(last, "last");
Ensure.ArgumentNotNull(converter, "converter");
_last = last;
_converter = converter;
}
private static IntermediateModifierEntry CreateFilledEntry(
IFormBuilder form = null, IStatBuilder stat = null, IValueBuilder value = null,
IConditionBuilder condition = null)
=> new IntermediateModifierEntry(
form ?? Mock.Of <IFormBuilder>(),
stat ?? Mock.Of <IStatBuilder>(),
value ?? Mock.Of <IValueBuilder>(),
condition ?? Mock.Of <IConditionBuilder>());
/// <summary>
/// 添加IsNotNull条件过滤
/// </summary>
/// <param name="builder">生成器</param>
/// <param name="fieldName">字段名</param>
/// <param name="appendCondition">是否拼接条件</param>
/// <returns></returns>
public static IConditionBuilder OrIsNotNull(this IConditionBuilder builder, string fieldName, bool appendCondition)
{
if (!appendCondition)
{
return(builder);
}
builder.Append <string>(RelationType.Or, fieldName, SqlOperator.IsNotNull);
return(builder);
}
/// <summary>
/// SQL Statement Build Provider Constructor
/// </summary>
/// <param name="selectStatementBuilder">Select Statement Builder</param>
/// <param name="insertStatementBuilder">Insert Statement Builder</param>
/// <param name="updateStatementBuilder">Update Statement Builder</param>
/// <param name="conditionBuilder">Condition Builder</param>
public SqlStatementBuildProvider(ISelectStatementBuilder selectStatementBuilder,
IInsertStatementBuilder insertStatementBuilder,
IUpdateStatementBuilder updateStatementBuilder,
IConditionBuilder conditionBuilder)
{
_selectStatementBuilder = selectStatementBuilder ?? throw new ArgumentNullException(nameof(selectStatementBuilder));
_insertStatementBuilder = insertStatementBuilder ?? throw new ArgumentNullException(nameof(insertStatementBuilder));
_updateStatementBuilder = updateStatementBuilder ?? throw new ArgumentNullException(nameof(updateStatementBuilder));
_conditionBuilder = conditionBuilder ?? throw new ArgumentNullException(nameof(conditionBuilder));
}
public static AndConditionBuilder And(this IConditionBuilder builder, IConditionBuilder rightBuilder)
{
var b = new AndConditionBuilder();
((IConditionBuildersHolder)b).ConditionBuilders.Add(builder);
((IConditionBuildersHolder)b).ConditionBuilders.Add(rightBuilder);
return(b);
}
protected ValueBuilder ChanceToHitValue(
IStatBuilder accuracyStat, IStatBuilder evasionStat, IConditionBuilder isBlinded)
{
var accuracy = accuracyStat.Value;
var evasion = evasionStat.Value;
var blindMultiplier = ValueFactory.If(isBlinded).Then(0.5).Else(1);
return(100 * blindMultiplier * 1.15 * accuracy /
(accuracy + (evasion / 4).Select(d => Math.Pow(d, 0.8), v => $"{v}^0.8")));
}
public void Add(
[RegexPattern] string regex, ValueBuilder multiplier, IConditionBuilder condition,
string substitution = "")
{
var builder = ModifierBuilder
.WithValueConverter(v => v.Multiply(multiplier))
.WithCondition(condition);
Add(regex, builder, substitution);
}
/// <summary>
/// And 条件连接
/// </summary>
/// <param name="builder">生成器</param>
/// <param name="condition">条件生成器</param>
/// <param name="appendCondition">是否拼接条件</param>
/// <returns></returns>
public static IConditionBuilder And(this IConditionBuilder builder,
Action <IConditionBuilder> condition, bool appendCondition)
{
if (appendCondition)
{
var child = builder.Clone();
condition.Invoke(child);
return(builder.Block(RelationType.And, child));
}
return(builder);
}
private IValue BuildConditionToValue(IConditionBuilder condition, BuildParameters parameters)
{
var result = condition.Build(parameters);
if (!result.HasValue)
{
throw new ParseException(
$"Can only use value conditions in {nameof(Count)}");
}
return(result.Value);
}
public IThenBuilder ElseIf(IConditionBuilder condition)
{
IThenBuilder Resolve(ResolveContext context)
{
return(new ThenBuilder(
$"{this.Resolve(context)} else if ({condition.Resolve(context)})",
(current, _) => current));
}
return(new ThenBuilder($"{this} else if ({condition})",
(_, context) => Resolve(context)));
}
public void Add(IFormBuilder form, IStatBuilder stat, IValueBuilder value, IConditionBuilder condition = null)
{
var builder = _modifierBuilder
.WithForm(form)
.WithStat(stat)
.WithValue(value);
if (condition != null)
{
builder = builder.WithCondition(condition);
}
_data.Add(builder.Build());
}
/// <summary>
/// 添加NotIn条件过滤
/// </summary>
/// <param name="builder">生成器</param>
/// <param name="fieldName">字段名</param>
/// <param name="childQuery">子查询，例如：select Id from User</param>
/// <param name="appendCondition">是否拼接条件</param>
/// <returns></returns>
public static IConditionBuilder OrNotIn(this IConditionBuilder builder, string fieldName, string childQuery, bool appendCondition)
{
if (!appendCondition)
{
return(builder);
}
if (string.IsNullOrWhiteSpace(childQuery))
{
return(builder);
}
builder.AppendRaw(RelationType.Or, string.Format(" {0} NOT IN ({1})", fieldName, childQuery));
return(builder);
}
public void Constructor_GivenNullConditionBuilder_ShouldThrowException()
{
//---------------Set up test pack-------------------
var insertStatementBuilder = Substitute.For <IInsertStatementBuilder>();
IConditionBuilder conditionBuilder = null;
var actorProps = Props.Create <HeliumConstructInsertSqlQueryActor>(insertStatementBuilder, conditionBuilder);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
EventFilter.Exception(typeof(ArgumentNullException), contains: "Parameter name: conditionBuilder", checkInnerExceptions: true)
.Expect(1, () => Sys.ActorOf(actorProps, "Test"));
//---------------Test Result -----------------------
}
/// <summary>
/// 添加尾匹配条件过滤
/// </summary>
/// <typeparam name="T">字段值类型</typeparam>
/// <param name="builder">生成器</param>
/// <param name="fieldName">字段名</param>
/// <param name="value">字段值</param>
/// <param name="appendCondition">是否拼接条件</param>
/// <returns></returns>
public static IConditionBuilder OrEnds <T>(this IConditionBuilder builder, string fieldName, T value,
bool appendCondition)
{
if (!appendCondition)
{
return(builder);
}
if (value == null)
{
return(builder);
}
builder.Append(RelationType.Or, fieldName, SqlOperator.Ends, value);
return(builder);
}
/// <summary>
/// 添加In条件过滤
/// </summary>
/// <typeparam name="T">字段值类型</typeparam>
/// <param name="builder">生成器</param>
/// <param name="fieldName">字段名</param>
/// <param name="value">字段值</param>
/// <param name="appendCondition">是否拼接条件</param>
/// <returns></returns>
public static IConditionBuilder In <T>(this IConditionBuilder builder, string fieldName, T[] value,
bool appendCondition)
{
if (!appendCondition)
{
return(builder);
}
if (value == null)
{
return(builder);
}
builder.Append(RelationType.And, fieldName, SqlOperator.In, value);
return(builder);
}
public SkillPreParseResult(
SkillDefinition skillDefinition, SkillLevelDefinition levelDefinition, SkillDefinition mainSkillDefinition,
ModifierSource.Local.Skill localSource, ModifierSource.Global globalSource, Entity modifierSourceEntity,
IConditionBuilder isMainSkill, IConditionBuilder isActiveSkill)
{
SkillDefinition = skillDefinition;
LevelDefinition = levelDefinition;
MainSkillDefinition = mainSkillDefinition;
LocalSource = localSource;
GlobalSource = globalSource;
ModifierSourceEntity = modifierSourceEntity;
IsMainSkill = isMainSkill;
IsActiveSkill = isActiveSkill;
}
public IModifierBuilder WithCondition(IConditionBuilder condition)
{
if (condition == null)
{
throw new ArgumentNullException(nameof(condition));
}
if (Conditions != null)
{
throw new InvalidOperationException();
}
var ret = (ModifierBuilderStub)MemberwiseClone();
ret.Conditions = new[] { condition };
return(ret);
}
/// <summary>
/// Adds a matcher with a form, value, stat and optionally a condition.
/// </summary>
public void Add([RegexPattern] string regex, IFormBuilder form, IValueBuilder value, IStatBuilder stat,
IConditionBuilder condition = null)
{
var builder = ModifierBuilder
.WithForm(form)
.WithStat(stat)
.WithValue(value);
if (condition != null)
{
builder = builder.WithCondition(condition);
}
Add(regex, builder);
}
public static OrConditionBuilder Or(this OrConditionBuilder builder, IConditionBuilder rightBuilder)
{
if (rightBuilder is OrConditionBuilder) // Merge the condition builders
{
builder.Conditions(
((IConditionBuildersHolder)rightBuilder).ConditionBuilders.ToArray()
);
}
else
{
builder.Conditions(rightBuilder);
}
return(builder);
}
private void Add(
IStatBuilder stat, Form form, IValueBuilder value, IConditionBuilder condition,
ModifierSource modifierSource)
{
var builder = _modifierBuilder
.WithStat(stat)
.WithForm(_builderFactories.FormBuilders.From(form))
.WithValue(value);
if (condition != null)
{
builder = builder.WithCondition(condition);
}
var intermediateModifier = builder.Build();
_modifiers.AddRange(intermediateModifier.Build(modifierSource, _modifierSourceEntity));
}
