public ValidationResult ValidateResource(EditTradeResource resource)
{
var result = new ValidationResult();
if (resource != null)
{
var validator = new TradeValidator();
var vr = validator.Validate(resource);
if (vr.IsValid)
{
result.IsValid = true;
return(result);
}
if (vr.Errors.Any())
{
foreach (var error in vr.Errors)
{
result.ErrorMessages.Add(error.PropertyName, error.ErrorMessage);
}
}
}
return(result);
}
private TradeValidator GetObjectUnderTest()
{
var settingsRepositoryMock = new Mock <IValidationSettingsRepository>();
settingsRepositoryMock.Setup(s => s.Get()).Returns(Settings);
var underTest = new TradeValidator(settingsRepositoryMock.Object);
return(underTest);
}
public static async Task CreateGts(Client c, string offer, string request, string index)
{
//If user is banned, return
if (await Database.DbUserChecks.UserBanned(c.Username))
{
await c.SendMessage($"<GTSCREATE result=0 index={index}>");
return;
}
//If user has more than max amount of allowed GTS trades, return
if (await Database.Dbgts.GetNumberOfTrades(c.UserId) >= Data.MaximumGtsTradesPerUser)
{
await c.SendMessage($"<GTSCREATE result=1 index={index}>");
return;
}
//Decode data
var decodeOffer = Utilities.Encoding.Base64Decode(offer);
var decodeRequest = Utilities.Encoding.Base64Decode(request);
int level;
try
{
//Turn data into objects
var pokemon = JsonConvert.DeserializeObject <GamePokemon>(decodeOffer);
if (!await TradeValidator.IsPokemonValid(pokemon, c.UserId))
{
await c.SendMessage($"<GTSCREATE result=0 index={index}>");
return;
}
//Get Pokemon Level
level = GrowthRates.CalculateLevel(pokemon.species, pokemon.exp);
}
catch (InvalidCastException)
{
await c.SendMessage($"<GTSCREATE result=2 index={index}>");
return;
}
//Input in database
try
{
await Database.Dbgts.Add(c.UserId, decodeOffer, decodeRequest, level, c.Username);
await c.SendMessage($"<GTSCREATE result=3 index={index}>");
}
catch (Exception e)
{
Console.WriteLine(e);
await c.SendMessage($"<GTSCREATE result=2 index={index}>");
}
}
public void ShouldNotValidateClientsList()
{
//Arrange
TradeValidator tradeValidator = new TradeValidator(clientsRepository, shareRepository, clientsSharesRepository);
IEnumerable <ClientEntity> clients = new List <ClientEntity>();
//Act
var isValid = tradeValidator.ValidateClientList(clients, logger);
//Assert
Assert.AreEqual(false, isValid);
}
public void ShouldNotValidateChangeClientMoney()
{
//Arrange
TradeValidator tradeValidator = new TradeValidator(clientsRepository, shareRepository, clientsSharesRepository);
int clientID = 22;
int amount = 200;
//Act
var isValid = tradeValidator.ValidateClientMoney(clientID, amount, logger);
//Assert
Assert.AreEqual(false, isValid);
clientsRepository.Received(1).LoadClientByID(clientID);
}
public void ShouldNotValidateTradingClient()
{
//Arrange
TradeValidator tradeValidator = new TradeValidator(clientsRepository, shareRepository, clientsSharesRepository);
ClientEntity client = new ClientEntity()
{
ClientID = 1
};
//Act
var isValid = tradeValidator.ValidateTradingClient(client, logger);
//Assert
Assert.AreEqual(false, isValid);
}
public void ShouldNotValidateShareInfo()
{
//Arrange
TradeValidator tradeValidator = new TradeValidator(clientsRepository, shareRepository, clientsSharesRepository);
ShareRegistrationInfo shareInfo = new ShareRegistrationInfo()
{
Name = "CostCorp",
Cost = 0
};
//Act
var isValid = tradeValidator.ValidateShareInfo(shareInfo, logger);
//Assert
Assert.AreEqual(false, isValid);
}
public void ShouldNotValidateClientInfo()
{
//Arrange
TradeValidator tradeValidator = new TradeValidator(clientsRepository, shareRepository, clientsSharesRepository);
ClientRegistrationInfo clientInfo = new ClientRegistrationInfo()
{
FirstName = "566",
LastName = "*****@*****.**",
PhoneNumber = "Josh"
};
//Act
var isValid = tradeValidator.ValidateClientInfo(clientInfo, logger);
//Assert
Assert.AreEqual(false, isValid);
}
public OpenCloseStrategyDecision()
{
//decision strength variables
BuyCounter = 0;
SellCounter = 0;
prevDecision = StrategyDecision.None;
prevDecisionType = StrategyDecision.None;
AllDecisions =
new HashSet <StrategyDecision> {
StrategyDecision.Open,
StrategyDecision.OpenMissed,
StrategyDecision.TakeProfit,
StrategyDecision.ExitHeavy,
StrategyDecision.Exit,
StrategyDecision.Escape
};
//missedposition decision variables
MissedPositionStartCandleIndex = OpenCloseStrategySettings.settings.MissedPositionStartCandleIndex;
MissedPositionEndCandleIndex = OpenCloseStrategySettings.settings.MissedPositionEndCandleIndex;
//heavyloss decision variables
ExitImmediate = OpenCloseStrategySettings.settings.ExitImmediate;
HeavyRiskPercentage = OpenCloseStrategySettings.settings.HeavyRiskPercentage;
//escape decision variables
//EscapeTraps = OpenCloseStrategySettings.settings.EscapeTraps;
EscapeTrapCandleIdx = OpenCloseStrategySettings.settings.EscapeTrapCandleIdx;
//set variables to avoid wrong trades (trade validation)
RequiredSignalGap = OpenCloseStrategySettings.settings.SignalGap;
BollingerFactor = OpenCloseStrategySettings.settings.BollingerFactor;
RequiredSignalQuality = OpenCloseStrategySettings.settings.RequiredSignalQuality;
ConsistentKandlesLookBack = OpenCloseStrategySettings.settings.ConsistentKandlesLookBack;
ValidationRuleSet = OpenCloseStrategySettings.settings.ValidationRuleSet; //ruleset
DecisionSet = new HashSet <string>(OpenCloseStrategySettings.settings.DecisionSet.Split(',')); //decisionset
validator = new TradeValidator(ValidationRuleSet);
//decision signal strengths
OpenPositionSignalStrength = OpenCloseStrategySettings.settings.OpenPositionSignalStrength;
MissedPositionSignalStrength = OpenCloseStrategySettings.settings.MissedPositionSignalStrength;
ExitPositionHeavyLossSignalStrength = OpenCloseStrategySettings.settings.ExitPositionHeavyLossSignalStrength;
ExitSignalStrength = OpenCloseStrategySettings.settings.ExitSignalStrength;
TakeProfitSignalStrength = OpenCloseStrategySettings.settings.TakeProfitSignalStrength;
EscapeTrapSignalStrength = OpenCloseStrategySettings.settings.EscapeTrapSignalStrength;
}
public void ShouldNotValidateNegativeShareToClientInfo()
{
//Arrange
TradeValidator tradeValidator = new TradeValidator(clientsRepository, shareRepository, clientsSharesRepository);
ClientsSharesInfo clientShareInfo = new ClientsSharesInfo()
{
ClientID = 1,
ShareID = 2,
Amount = -30
};
//Act
var isValid = tradeValidator.ValidateShareToClient(clientShareInfo, logger);
//Assert
Assert.AreEqual(false, isValid);
clientsRepository.Received(1).LoadClientByID(clientShareInfo.ClientID);
shareRepository.Received(1).LoadShareByID(clientShareInfo.ShareID);
clientsSharesRepository.Received(1).LoadClientsSharesByID(clientShareInfo);
}
private static TradesMonitor GetObjectUnderTest()
{
var validationSettings = new ValidationSettings()
{
OpenTimeDelta = 1,
VolumeToBalanceRatio = 0.05m,
};
var monitoringSettings = new MonitoringSettings()
{
RetentionPeriod = 3
};
var settingsRepositoryMock = new Mock <IValidationSettingsRepository>();
settingsRepositoryMock.Setup(r => r.Get()).Returns(validationSettings);
var monitoringSettingsRepositoryMock = new Mock <IMonitoringSettingsRepository>();
monitoringSettingsRepositoryMock.Setup(r => r.Get()).Returns(monitoringSettings);
var validator = new TradeValidator(settingsRepositoryMock.Object);
var loggerMock = new Mock <ILogger>();
var underTest = new TradesMonitor(validator, loggerMock.Object, monitoringSettingsRepositoryMock.Object);
return(underTest);
}
public void ShouldNotValidateTradingClientWithZeroShares()
{
//Arrange
TradeValidator tradeValidator = new TradeValidator(clientsRepository, shareRepository, clientsSharesRepository);
ClientEntity client = new ClientEntity()
{
ClientID = 1,
ClientsShares = new HashSet <ClientsSharesEntity>()
{
new ClientsSharesEntity()
{
ClientID = 1,
ShareID = 2,
Amount = 0
}
}
};
//Act
var isValid = tradeValidator.ValidateTradingClient(client, logger);
//Assert
Assert.AreEqual(false, isValid);
}
public static async Task AddTrade(Client client, string encodedPkmns)
{
if (await DbUserChecks.UserBanned(client.Username))
{
await client.SendMessage("<WTRESULT reult=0 user=nil pkmn=nil>");
return;
}
if (List.Count(x => x.Value.Client == client) > 0)
{
return;
}
GamePokemon pkmn;
try
{
pkmn = JsonConvert.DeserializeObject <GTS.GamePokemon>(
Utilities.Encoding.Base64Decode(encodedPkmns));
}
catch
{
await client.SendMessage("<WTRESULT result=1 user=nil pkmn=nil>");
throw;
}
if (!await TradeValidator.IsPokemonValid(pkmn, client.UserId))
{
await client.SendMessage("<WTRESULT reult=0 user=nil pkmn=nil>");
return;
}
var holder = new WonderTradeHolder(client, pkmn);
List.TryAdd(holder.Id, holder);
}
public TradeValidatorTests()
{
_validator = new TradeValidator();
}
public static async Task OfferGts(Client c, string pokemon, string idstr)
{
uint id;
if (!uint.TryParse(idstr, out id))
{
return;
}
//If user is banned, return
if (await Database.DbUserChecks.UserBanned(c.Username))
{
await c.SendMessage("<GTSOFFER result=0 pkmn=nil>");
return;
}
//Get Pokemon data from Database
var poke = await Database.Dbgts.GetSingleTrade(id);
//If already accepted send negative response
if (poke == null || poke.Accepted)
{
await c.SendMessage("<GTSOFFER result=1 pkmn=nil>");
return;
}
//decode string
var decoded = Utilities.Encoding.Base64Decode(pokemon);
//string to object
var pkmn = JsonConvert.DeserializeObject <GamePokemon>(decoded);
if (!await TradeValidator.IsPokemonValid(pkmn, c.UserId))
{
await c.SendMessage("<GTSOFFER result=0 pkmn=nil>");
return;
}
var request = poke.Request;
//Compare pokemon offered with requests on pokemon with id offered.
var correct = GtsCompare.ValidOffer(pkmn, request);
//If doesn't match, send negative response
if (correct == false)
{
await c.SendMessage("<GTSOFFER result=2 pkmn=nil>");
return;
}
//If it has been accepted, return negative (we do this twice to make absolutely sure it hasn't been traded in between)
if (await Database.Dbgts.GetAccepted(id))
{
await c.SendMessage("<GTSOFFER result=1 pkmn=nil>");
return;
}
//Set accepted to true, Set pokemon offered as pokemon for collector to receive
await Database.Dbgts.SetAccepted(id, decoded);
//Send positive response along with pokemon back to client.
var encodedPokemon = Utilities.Encoding.Base64Encode(JsonConvert.SerializeObject(poke.Offer));
await c.SendMessage($"<GTSOFFER result=3 pkmn={encodedPokemon}>");
}
