public CoinFlipServiceTest()
{
_fakedHashService = A.Fake <IHashService>();
_fakedRandomService = A.Fake <IRandomService>();
var fakedRepoServcieFacotry = A.Fake <IRepoServiceFactory>();
_fakedCoinFlipMatchRepoService = A.Fake <ICoinFlipMatchRepoService>();
_fakedUserRepoService = A.Fake <IUserRepoService>();
_fakedGameModeRepoSerivce = A.Fake <IGameModeRepoService>();
_fakedTransactionFactory = A.Fake <ITransactionFactory>();
_fakedTransactionWrapper = A.Fake <ITransactionWrapper>();
_fakedBetService = A.Fake <IBetService>();
_fakedItemService = A.Fake <IItemService>();
_fakedJackpotSettingRepoService = A.Fake <IJackpotSettingRepo>();
_fakedMongoDbJackpotRepoService = A.Fake <IMongoJackpotRepoService>();
_fakedMongoDbPreHashRepoService = A.Fake <IMongoPreHashRepoService>();
A.CallTo(() => _fakedTransactionFactory.BeginTransaction()).Returns(_fakedTransactionWrapper);
A.CallTo(() => fakedRepoServcieFacotry.CoinFlipMatchRepoService).Returns(_fakedCoinFlipMatchRepoService);
A.CallTo(() => fakedRepoServcieFacotry.GameModeRepoService).Returns(_fakedGameModeRepoSerivce);
A.CallTo(() => fakedRepoServcieFacotry.UserRepoService).Returns(_fakedUserRepoService);
A.CallTo(() => fakedRepoServcieFacotry.JackpotSettingRepo).Returns(_fakedJackpotSettingRepoService);
_defaultSetting = new CreateCoinFlipSettingModel
{
AllowCsgo = true,
AllowPubg = false,
Diff = 1000,
MaxItem = 10,
MinItem = 0,
PreHash = "ranomdHash"
};
_coinFlipService = new CoinFlipService
(
_fakedHashService,
_fakedRandomService,
fakedRepoServcieFacotry,
_fakedTransactionFactory,
_fakedBetService,
_fakedItemService,
_fakedMongoDbJackpotRepoService,
A.Dummy <ICoinFlipHubConnections>(),
_fakedMongoDbPreHashRepoService,
A.Dummy <IDiscordService>()
);
//TODO CHECK ALL DUMMY TEST OBJECTS!
}
private DatabaseModel.JackpotSetting CreateJackpotSetting(CreateCoinFlipSettingModel setting, decimal totalValueOfItems)
{
var factor = ((setting.Diff / new decimal(100.0)) + 1);
var maxDiff = (totalValueOfItems * factor);
var minDiff = (totalValueOfItems / factor);
var jackpotSetting = new DatabaseModel.JackpotSetting
(
5,
10 * 1000,
setting.MaxItem * 2,
setting.MaxItem,
setting.MinItem,
decimal.Round(maxDiff, 2),
decimal.Round(minDiff, 2),
10 * 1000,
setting.AllowCsgo,
setting.AllowPubg,
"drafting graph"
);
return(jackpotSetting);
}
public async Task <IActionResult> CreateCoinFlipMatch([FromBody] CreateCoinFlipModel model)
{
var userSteamId = User.GetSteamId();
if (!model.Settings.AllowCsgo && !model.Settings.AllowPubg)
{
return(BadRequest("Either CSGO or PUBG must be enabled."));
}
if (string.IsNullOrEmpty(model.CoinFlipPreHash))
{
return(BadRequest("Prehash needs to bet set inorder to create a match."));
}
// if (model.Items.Count > model.Settings.MaxItem)
// return BadRequest("You can't have a lower maxItem limit then you have betted items");
//
// if (model.Items.Count < model.Settings.MinItem)
// return BadRequest("You can't have a higher minItem limit then you have betted items");
if (model.Settings.Diff < 5)
{
return(BadRequest("The diff value can't be less than 5%"));
}
if (model.Settings.Diff > 10000) //Upper limit is retarded and only sets limits for the users..
{
return(BadRequest("The diff value can't be grater than 10000%"));
}
var setting = new CreateCoinFlipSettingModel
{
AllowCsgo = model.Settings.AllowCsgo,
AllowPubg = model.Settings.AllowPubg,
MaxItem = 10,
MinItem = 1,
Diff = model.Settings.Diff,
PreHash = model.CoinFlipPreHash,
};
try
{
var coinFlipMatch = await _coinFlipService.CreateMatch(userSteamId, model.IsHead, model.Items, setting);
return(Ok(coinFlipMatch));
}
catch (Exception ex)
{
if (
ex is GameModeIsNotEnabledException ||
ex is ToManyItemsOnBetException ||
ex is ToFewItemsOnBetException ||
ex is NotAllowedAppIdOnMatchException ||
ex is ToMuchValueOnBetException ||
ex is ToLittleValueOnBetException ||
ex is InvalidItemException
)
{
return(BadRequest(ex.Message));
}
if (ex is ToOldPreHashException)
{
return(StatusCode(410, "Some error ocured, please try again"));
}
if (ex is PreHashNotFoundException)
{
var location = ControllerContext.HttpContext.Items["location"].ToString();
var arguments = ControllerContext.HttpContext.Items["arguments"] as Dictionary <string, object>;
_logService.Error(userSteamId, location, ex, arguments);
return(StatusCode(404, "Did not found the hash, try again"));
}
throw;
}
}
public async Task <CoinFlipMatch> CreateMatch
(
string creatorSteamId,
bool creatorIsHead,
List <AssetAndDescriptionId> assetAndDescriptionIds,
CreateCoinFlipSettingModel setting
)
{
var user = await _repoServiceFactory.UserRepoService.FindAsync(creatorSteamId);
if (user == null)
{
throw new UserDoesNotExistException($"The user does with steamId {creatorSteamId} not exist.");
}
if (assetAndDescriptionIds.Count == 0)
{
throw new InvalidBetException("No items selected");
}
var items = await _repoServiceFactory.ItemRepoService.FindAsync(assetAndDescriptionIds);
var totalValueOfItems = await _itemService.GetSumOfItems(items);
var jackpotSetting = CreateJackpotSetting(setting, totalValueOfItems);
var jackpotMatchSetting = jackpotSetting.ToJackpotMatchSetting();
var itemDescsIds = assetAndDescriptionIds.Select(item => item.DescriptionId).Distinct().ToList();
var itemDescriptionTask = _repoServiceFactory.ItemDescriptionRepoService.FindAsync(itemDescsIds);
var gameModeTask = _repoServiceFactory.GameModeRepoService.Find(GameModeHelper.GetStringFromType(GameModeType.CoinFlip));
var getPreHashTask = _preHashRepoService.Find(setting.PreHash, creatorSteamId);
await Task.WhenAll(gameModeTask, itemDescriptionTask, getPreHashTask);
if (!gameModeTask.Result.IsEnabled)
{
throw new GameModeIsNotEnabledException("The current gamemode CoinFlip is not enabled at the moment.");
}
var match = CreateCoinFlipMatch(creatorIsHead, user, gameModeTask.Result, getPreHashTask.Result);
var insertedMatch = await InsertedMatchAndBetWithTransaction
(
assetAndDescriptionIds,
match,
jackpotSetting,
gameModeTask.Result,
items,
user,
itemDescriptionTask.Result,
jackpotMatchSetting
);
var mongoDbMatch = await InsertIntoMongoDb(insertedMatch, items, itemDescriptionTask.Result, jackpotMatchSetting, user);
var coinFlipMatch = new CoinFlipMatch(mongoDbMatch);
await _coinFlipHubConnections.MatchCreated(coinFlipMatch);
_discordService.CoinFlipCreateAsync(setting.AllowCsgo, setting.AllowPubg, totalValueOfItems, match.RoundId, user.SteamId);
return(coinFlipMatch);
}
