private async Task <JackpotMatch> GetMatch(DatabaseModel.JackpotSetting settings, DatabaseModel.Match match, DatabaseModel.GameMode gameMode)
{
var items = await _betService.GetBettedItemsOnMatch(match.Id, gameMode.Id) ?? new List <Item>();
return(new JackpotMatch(
match.RoundId.ToString(),
match.Hash,
match.Salt,
match.Percentage,
MatchStatusHelper.GetMatchStatusFromInt(match.Status),
await GetBets(items, match.Id, gameMode),
match.TimerStarted,
settings.ToJackpotMatchSetting()
));
}
public async Task <Result <CoinFlipMatchHistory> > GetHistory(int start, int count)
{
var filter = GetFindFilter().Where(match => match.Status == MatchStatusHelper.GetIntFromMatchStatus(MatchStatus.Closed));
var res = await MongoDbHelper.Query(GetCollection().Collection, filter, start, count, match => match.TimerStarted);
var result = new Result <CoinFlipMatchHistory>
{
CurrentIndex = start,
Total = res.Total,
Data = res.Data.Select(i => new CoinFlipMatchHistory(i)).ToList()
};
return(result);
}
public async Task <JackpotMatchHistoryDetailed> GetMatchHistory(int roundId)
{
var match = await _repoServiceFactory.MatchRepoService.FindAsync(roundId);
if (MatchStatusHelper.GetMatchStatusFromInt(match.Status) == MatchStatus.Open)
{
throw new Exception("Can't fetch history data on active round!");
}
var rakeItems = await _repoServiceFactory.RakeItemRepoService.FindAsync(match);
var itemsBetted = await _betService.GetBettedItemsOnMatch(match.Id, match.GameModeId);
var basic = await GetHistoryBasic(match);
var historyDetailed = new JackpotMatchHistoryDetailed
{
Bets = await GetBets(itemsBetted, match.Id, _gameMode),
Created = basic.Created,
Hash = basic.Hash,
Percentage = basic.Percentage,
RoundId = basic.RoundId,
Salt = basic.Salt,
UserWinnerImgUrl = basic.UserWinnerImgUrl,
UserWinnerName = basic.UserWinnerName,
UserWinnerQuote = basic.UserWinnerQuote,
UserWinnerSteamId = basic.UserWinnerSteamId
};
foreach (var rakeItem in rakeItems)
{
foreach (var bet in historyDetailed.Bets)
{
foreach (var betItem in bet.Items)
{
if (betItem.AssetId == rakeItem.AssetId && betItem.DescriptionId == rakeItem.DescriptionId)
{
betItem.TookAsRake = true;
}
}
}
}
return(historyDetailed);
}
public async Task <Result <CoinFlipMatchHistory> > GetPersonalHistory(int start, int count, string steamId)
{
var betFilter = new BsonDocumentFilterDefinition <MongoDbModels.JackpotMatch>(new BsonDocument("Bets.User.SteamId", steamId));
var filter = GetFindFilter().And
(
betFilter,
GetFindFilter().Where(match => match.Status == MatchStatusHelper.GetIntFromMatchStatus(MatchStatus.Closed))
);
var res = await MongoDbHelper.Query(GetCollection().Collection, filter, start, count, match => match.TimerStarted);
var result = new Result <CoinFlipMatchHistory>
{
CurrentIndex = start,
Total = res.Total,
Data = res.Data.Select(i => new CoinFlipMatchHistory(i)).ToList()
};
return(result);
}
public async Task <DatabaseModel.Match> CreateNewMatchAsync(int roundId)
{
var settingRes = await _gameModeSettingService.GetSettingForType(GameModeType.JackpotCsgo);
_currentMatchSettings = (DatabaseModel.JackpotSetting)settingRes ?? throw new NullReferenceException("The match setting is NULL!");
_gameMode = await _repoServiceFactory.GameModeRepoService.Find(GameModeHelper.GetStringFromType(GameModeType.JackpotCsgo));
var res = await base.CreateNewMatchAsync(roundId, _gameMode);
var jackpotMatch = new JackpotMatch(
roundId.ToString(),
res.Hash,
res.Salt,
res.Percentage,
MatchStatusHelper.GetMatchStatusFromInt(res.Status),
new List <Bet>(),
res.TimerStarted,
new JackpotMatchSetting(
_currentMatchSettings.Rake,
TimeSpan.FromMilliseconds(_currentMatchSettings.TimmerInMilliSec),
_currentMatchSettings.ItemsLimit,
_currentMatchSettings.MaxItemAUserCanBet,
_currentMatchSettings.MinItemAUserCanBet,
_currentMatchSettings.MaxValueAUserCanBet,
_currentMatchSettings.MinValueAUserCanBet,
_currentMatchSettings.AllowCsgo,
_currentMatchSettings.AllowPubg,
TimeSpan.FromMilliseconds(_currentMatchSettings.DraftingTimeInMilliSec),
_currentMatchSettings.DraftingGraph
)
);
await _matchHubConnections.NewMatchCreated(jackpotMatch);
_isClosed = false;
return(res);
}
protected async Task <DatabaseModel.Match> CreateNewMatchAsync(int roundId, DatabaseModel.GameMode currentGameMode)
{
var percentage = _randomService.GeneratePercentage();
var salt = _randomService.GenerateSalt();
var hash = _hashService.CreateBase64Sha512Hash(percentage, salt);
var status = MatchStatusHelper.GetIntFromMatchStatus(MatchStatus.Open);
var match = new DatabaseModel.Match
(
roundId,
salt,
hash,
percentage,
status,
null,
null,
currentGameMode.CurrentSettingId,
currentGameMode.Id,
DateTime.Now
);
return(await _matchRepoService.InsertAsync(match));
}
private bool ShouldCloseMatch(DatabaseModel.Match match, List <DatabaseModel.ItemBetted> itemBets, int currentBetCount)
{
if (MatchStatusHelper.GetMatchStatusFromInt(match.Status) == MatchStatus.Closed)
{
return(true);
}
var itemLimit = _currentMatchSettings.ItemsLimit;
if (itemBets.Count + currentBetCount >= itemLimit && itemBets.Select(i => i.BetId).Distinct().Count() > 1)
{
return(true);
}
var jackPotTimespan = (TimeSpan.FromMilliseconds(_currentMatchSettings.TimmerInMilliSec));
if (match.TimerStarted.HasValue && (DateTime.Now - (match.TimerStarted.Value + jackPotTimespan)).TotalMilliseconds > 0)
{
return(true);
}
return(false);
}
public void MatchIsClosedReturnsIntSucces()
{
Assert.Equal(0, MatchStatusHelper.GetIntFromMatchStatus(MatchStatus.Closed));
}
public void MatchIsOpenReturnsEnumSucces()
{
Assert.Equal(MatchStatus.Open, MatchStatusHelper.GetMatchStatusFromInt(1));
}
public void MatchIsClosedReturnsEnumSucces()
{
Assert.Equal(MatchStatus.Closed, MatchStatusHelper.GetMatchStatusFromInt(0));
}
public void MatchIsOpenReturnsIntSucces()
{
Assert.Equal(1, MatchStatusHelper.GetIntFromMatchStatus(MatchStatus.Open));
}
public async Task CloseMatch(int roundId)
{
var query = _matchQueries.ChangeMatchStatus(roundId, MatchStatusHelper.GetIntFromMatchStatus(MatchStatus.Closed));
await _databaseConnection.ExecuteNonQueryAsync(query);
}
