private string GetOperatorAsString(ComparisonEnum op)
{
switch (op)
{
case ComparisonEnum.Greater:
return("greater than");
case ComparisonEnum.GreaterOrEqual:
return("greater or equal to");
case ComparisonEnum.Less:
return("less than");
case ComparisonEnum.LessOrEqual:
return("less or equal to");
case ComparisonEnum.Is:
return("must be");
case ComparisonEnum.Of:
return("");
case ComparisonEnum.For:
return("For");
default:
return("");
}
}
public RiskProfileCheckConfigurationBuilder SetupWinLoss(decimal amount, ComparisonEnum @operator)
{
Configuration.HasWinLoss = true;
Configuration.WinLossAmount = amount;
Configuration.WinLossOperator = @operator;
return(this);
}
public AvcConfigurationBuilder SetupTotalWithdrawalCountAmount(int amount, ComparisonEnum @operator)
{
Configuration.HasWithdrawalCount = true;
Configuration.TotalWithdrawalCountAmount = amount;
Configuration.TotalWithdrawalCountOperator = @operator;
return(this);
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="pi">属性</param>
/// <param name="value">值</param>
/// <param name="comparison">比较类型</param>
/// <param name="condition">条件类型</param>
public FilterInfo(PropertyInfo pi, object value, ComparisonEnum comparison = ComparisonEnum.Equal, ConditionEnum condition = ConditionEnum.And)
{
PropertyInfo = pi;
Value = value;
Comparison = comparison;
Condition = condition;
TargetFunc = null;
}
public RiskProfileCheckConfigurationBuilder SetupDepositCount(int amount, ComparisonEnum @operator)
{
Configuration.HasDepositCount = true;
Configuration.TotalDepositCountAmount = amount;
Configuration.TotalDepositCountOperator = @operator;
return(this);
}
public RiskProfileCheckConfigurationBuilder SetupAccountAge(int age, ComparisonEnum @operator)
{
Configuration.HasAccountAge = true;
Configuration.AccountAge = age;
Configuration.AccountAgeOperator = @operator;
return(this);
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="piName">属性名称</param>
/// <param name="value">值</param>
/// <param name="comparison">比较类型</param>
/// <param name="condition">条件类型</param>
public FilterInfo(string piName, object value, ComparisonEnum comparison = ComparisonEnum.Equal, ConditionEnum condition = ConditionEnum.And)
{
var type = typeof(T);
var pi = type.GetProperty(piName);
PropertyInfo = pi ?? throw new ArgumentNullException($"类型{type.Name}上不存属性{piName}");
Value = value;
Comparison = comparison;
Condition = condition;
TargetFunc = null;
}
/// <summary>
/// Based on the step, operation, criteria value and actual value, this method returns an object
/// that contains full rule description and actual value for that rule which will be stored into the DB.
/// </summary>
/// <param name="step">DepositCount, AccountAge, WithdrawalCount etc.</param>
/// <param name="op">LessOrEqual, Is, Of etc.</param>
/// <param name="ruleValue">Tha value for the rule as it is in the criteria</param>
/// <param name="actualValue">Actual value for that rule coming from the WD request</param>
/// <returns></returns>
protected CompleteRuleDescriptionAndActualValue GenerateFullRuleDescriptionAndValue(
VerificationStep step, ComparisonEnum op, string ruleValue, string actualValue)
{
var enumDescription = GetEnumDescription(step);
var comparisonOperator = GetOperatorAsString(op);
var result = new CompleteRuleDescriptionAndActualValue()
{
CompleteRuleDescription = string.Format("{0} {1}", enumDescription, comparisonOperator),
RuleRequiredValues = ruleValue,
ActualVerificationValue = actualValue
};
return(result);
}
protected bool IsRulePassed(ComparisonEnum op, decimal ruleAmount, decimal actualAmount)
{
switch (op)
{
case ComparisonEnum.Greater:
return(ruleAmount < actualAmount);
case ComparisonEnum.Less:
return(ruleAmount > actualAmount);
case ComparisonEnum.GreaterOrEqual:
return(ruleAmount <= actualAmount);
case ComparisonEnum.LessOrEqual:
return(ruleAmount >= actualAmount);
}
return(false);
}
private static string ComparisonOperatorInterpreted(ComparisonEnum op)
{
switch (op)
{
case ComparisonEnum.Greater:
return(">");
case ComparisonEnum.Less:
return("<");
case ComparisonEnum.GreaterOrEqual:
return(">=");
case ComparisonEnum.LessOrEqual:
return("<=");
default:
return("");
}
}
public static Expression <Func <TSource, bool> > SimpleComparison <TSource>(string property, object value, ComparisonEnum comparison)
{
var type = typeof(TSource);
var pe = Expression.Parameter(type, "p");
MemberExpression propertyReference;
if (property.Contains("."))
{
var propSplit = property.Split(char.Parse("."));
var innerProp = type.GetProperty(propSplit[0]);
var childProp = innerProp.PropertyType.GetProperty(propSplit[1]);
var inner = Expression.Property(pe, innerProp);
propertyReference = Expression.Property(inner, childProp);
}
else
{
propertyReference = Expression.Property(pe, property);
}
var constantReference = Expression.Constant(value);
int intValue;
if (Int32.TryParse(value.ToString(), out intValue))
{
constantReference = Expression.Constant(intValue);
}
DateTime dateTimeValue;
if (DateTime.TryParse(value.ToString(), out dateTimeValue))
{
constantReference = Expression.Constant(dateTimeValue);
}
Expression compare = null;
switch (comparison)
{
case ComparisonEnum.Equal:
compare = Expression.Equal(propertyReference, constantReference);
break;
case ComparisonEnum.NotEqual:
compare = Expression.Not(Expression.Equal(propertyReference, constantReference));
break;
case ComparisonEnum.GreaterThanEqualTo:
compare = Expression.GreaterThanOrEqual(propertyReference, constantReference);
break;
}
return(Expression.Lambda <Func <TSource, bool> >(compare, new[] { pe }));
}
public async Task ComparisonService_Should_Update_ComparisonAsync(byte[] value, ComparisonEnum type)
{
ComparisonService comparisonService = new ComparisonService(_comparisonRepository.Object, _applicationDbContext.Object);
await comparisonService.InsertOrUpdateAsync(new ComparisonInsertRequestDto()
{
Id = id, Value = value, ValueType = type
});
byte[] newValue = new byte[4] {
1, 2, 3, 4
};
await comparisonService.InsertOrUpdateAsync(new ComparisonInsertRequestDto()
{
Id = id, Value = newValue, ValueType = type
});
comparison.Should().NotBeNull();
if (type == ComparisonEnum.Left)
{
comparison.LeftArray.Should().Equal(newValue);
}
else
{
comparison.RightArray.Should().Equal(newValue);
}
}
public async Task ComparisonService_ComparisonAsync_Should_Return_Equal_False(byte[] valueLeft, byte[] valueRight, ComparisonEnum type)
{
ComparisonService comparisonService = new ComparisonService(_comparisonRepository.Object, _applicationDbContext.Object);
await comparisonService.InsertOrUpdateAsync(new ComparisonInsertRequestDto()
{
Id = id, Value = valueLeft, ValueType = ComparisonEnum.Left
});
await comparisonService.InsertOrUpdateAsync(new ComparisonInsertRequestDto()
{
Id = id, Value = valueRight, ValueType = ComparisonEnum.Right
});
comparison.Should().NotBeNull();
ComparisonResponseDto result = await comparisonService.CompareAsync(new ComparisonRequestDto()
{
Id = id, ValueType = type
});
ComparisonResponseObject resultObject = (ComparisonResponseObject)result.Result;
resultObject.Equal.Should().BeFalse();
resultObject.SameSize.Should().BeTrue();
resultObject.Difference.Length.Should().Be(2);
var diffList = resultObject.Difference.OffSets.ToList();
if (type == ComparisonEnum.Left)
{
diffList[0].OffSet.Should().Be(0);
diffList[1].OffSet.Should().Be(3);
}
else
{
diffList[0].OffSet.Should().Be(2);
diffList[1].OffSet.Should().Be(3);
}
}
public async Task Comparison_Should_Throw_Exception_Due_To_Null_Right_Or_Left_Value(ComparisonEnum value, int id)
{
if (value == ComparisonEnum.Left)
{
await Should_Save_Left(id, new byte[4] {
1, 2, 3, 4
});
}
else
{
await Should_Save_Right(id, new byte[4] {
1, 2, 3, 4
});
}
CompareRequestModel requestModel = new CompareRequestModel();
requestModel.Type = ComparisonEnum.Left;
HttpResponseMessage response = await httpClient.PostAsync($"{host}/{id}", new StringContent(JsonConvert.SerializeObject(requestModel), Encoding.UTF8, "application/json"));
response.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
ResponseBase servicResponse = await response.ToResponseBaseAsync();
servicResponse.Success.Should().BeFalse();
if (value == ComparisonEnum.Left)
{
servicResponse.Message.Should().Be("Right array is null!");
}
else
{
servicResponse.Message.Should().Be("Left array is null!");
}
}
public RiskProfileCheckConfigurationBuilder SetupWithdrawalAverageChange(int amount, ComparisonEnum @operator)
{
Configuration.HasWithdrawalAverageChange = true;
Configuration.WithdrawalAverageChangeOperator = @operator;
Configuration.WithdrawalAverageChangeAmount = amount;
return(this);
}
protected bool IsRulePassed(ComparisonEnum op, int ruleAmount, int actualAmount)
{
return(IsRulePassed(op, (decimal)ruleAmount, (decimal)actualAmount));
}
public async void Win_Loss_rule_is_interpreted_in_oposite_manner_between_AVC_and_RPC(ComparisonEnum comparison, FraudRiskLevelStatus status)
{
var playerId = new Guid();
playerId = PickAPlayer(playerId);
CreateAvcConfiguration(new AVCConfigurationDTO
{
Licensee = _observedBrand.LicenseeId,
Brand = _observedBrand.Id,
Currency = _observedBrand.DefaultCurrency,
VipLevels = new[] { (Guid)_observedBrand.DefaultVipLevelId },
HasWinLoss = true,
WinLossAmount = 5,
WinLossOperator = ComparisonEnum.Greater,
Status = AutoVerificationCheckStatus.Active
});
_riskProfileCheckCommands.Create(new RiskProfileCheckDTO
{
Licensee = _observedBrand.LicenseeId,
Brand = _observedBrand.Id,
Currency = _observedBrand.DefaultCurrency,
VipLevels = new[] { (Guid)_observedBrand.DefaultVipLevelId },
HasWinLoss = true,
WinLossAmount = 5,
WinLossOperator = comparison,
});
await DepositBetAndWin(playerId);
var offlineWithdrawalRequest = new OfflineWithdrawRequest
{
Amount = 1,
NotificationType = NotificationType.None,
BankAccountTime = _paymentRepository.PlayerBankAccounts.First().Created.ToString(),
BankTime = _paymentRepository.Banks.First().Created.ToString(),
PlayerBankAccountId = _paymentRepository
.PlayerBankAccounts
.Include(x => x.Player)
.First(x => x.Player.Id == playerId)
.Id,
Remarks = "asd",
RequestedBy = _actorInfoProvider.Actor.UserName
};
AssertRiskProfileCheckStatus(offlineWithdrawalRequest,
_observedBrand,
status);
}
public async Task ComparisonService_ComparisonAsync_Should_Return_Equal_True(byte[] valueLeft, byte[] valueRight, ComparisonEnum type)
{
ComparisonService comparisonService = new ComparisonService(_comparisonRepository.Object, _applicationDbContext.Object);
await comparisonService.InsertOrUpdateAsync(new ComparisonInsertRequestDto()
{
Id = id, Value = valueLeft, ValueType = ComparisonEnum.Left
});
await comparisonService.InsertOrUpdateAsync(new ComparisonInsertRequestDto()
{
Id = id, Value = valueRight, ValueType = ComparisonEnum.Right
});
comparison.Should().NotBeNull();
ComparisonResponseDto result = await comparisonService.CompareAsync(new ComparisonRequestDto()
{
Id = id, ValueType = type
});
ComparisonResponseObject resultObject = (ComparisonResponseObject)result.Result;
resultObject.Equal.Should().BeFalse();
resultObject.SameSize.Should().BeTrue();
}
public RiskProfileCheckConfigurationBuilder SetupWinningsToDepositIncrease(int amount, ComparisonEnum @operator)
{
Configuration.HasWinningsToDepositIncrease = true;
Configuration.WinningsToDepositIncreaseOperator = @operator;
Configuration.WinningsToDepositIncreaseAmount = amount;
return(this);
}
public async Task Comparison_Should_Return_Equal_False(byte[] valueLeft, byte[] valueRight, ComparisonEnum type, int id)
{
await Should_Save_Left(id, valueLeft);
await Should_Save_Right(id, valueRight);
CompareRequestModel requestModel = new CompareRequestModel();
requestModel.Type = type;
HttpResponseMessage response = await httpClient.PostAsync($"{host}/{id}", new StringContent(JsonConvert.SerializeObject(requestModel), Encoding.UTF8, "application/json"));
response.StatusCode.Should().Be(HttpStatusCode.OK);
ResponseBase servicResponse = await response.ToResponseBaseAsync();
servicResponse.Success.Should().BeTrue();
ComparisonResponseObject resultObject = JsonConvert.DeserializeObject <ComparisonResponseObject>(servicResponse.Result.ToString());
resultObject.Equal.Should().BeFalse();
resultObject.SameSize.Should().BeTrue();
resultObject.Difference.Length.Should().Be(2);
var diffList = resultObject.Difference.OffSets.ToList();
if (type == ComparisonEnum.Left)
{
diffList[0].OffSet.Should().Be(0);
diffList[1].OffSet.Should().Be(3);
}
else
{
diffList[0].OffSet.Should().Be(2);
diffList[1].OffSet.Should().Be(3);
}
}
