public async Task GetAvalibleBotsForDepositUserBotHasNoSkinsSuccess()
{
var user = new DatabaseModel.User("steamId", "name", "imgUrl", "tade", DateTime.Now, DateTime.Now, false, null, 10);
var allItems = new List<DatabaseModel.Item>
{
new DatabaseModel.Item("assetId1", 1, 3, 6, DateTimeOffset.Now),
new DatabaseModel.Item("assetId2", 1, 3, 6, DateTimeOffset.Now),
new DatabaseModel.Item("assetId3", 1, 3, 6, DateTimeOffset.Now),
new DatabaseModel.Item("assetId4", 1, 7, 5, DateTimeOffset.Now),
new DatabaseModel.Item("assetId5", 1, 1, 5, DateTimeOffset.Now),
new DatabaseModel.Item("assetId6", 1, 1, 5, DateTimeOffset.Now),
new DatabaseModel.Item("assetId7", 1, 1, 1, DateTimeOffset.Now),
new DatabaseModel.Item("assetId8", 1, 1, 4, DateTimeOffset.Now),
};
A.CallTo(() => _fakedItemRepoService.GetAll()).Returns(allItems);
A.CallTo(() => _fakedItemRepoService.FindAsync(A<DatabaseModel.User>._))
.Returns(allItems.Where(item => item.OwnerId == user.Id).ToList());
A.CallTo(() => _fakedBotRepoService.FindAsync(154)).ReturnsLazily(call => Task.FromResult(CreateBot((int) call.Arguments[0])));
A.CallTo(() => _fakedBotRepoService.FindAsync(A<List<int>>._)).ReturnsLazily(CreateBots);
A.CallTo(() => _fakedBotRepoService.GetAll()).Returns(new List<DatabaseModel.Bot>
{
CreateBot(1),
CreateBot(154),
CreateBot(3),
CreateBot(7),
});
var bots = await _botService.GetAvalibleBotsForDeposit(user, new List<DatabaseModel.Item>());
Assert.Equal(1, bots.Count);
Assert.Equal(154, bots.Pop().Id);
A.CallTo(() => _fakedBotRepoService.FindAsync(154)).MustHaveHappened();
}
public async Task CreateMatchSuccess()
{
var percentage = 12.4587;
var percentageAsString = percentage.ToString(CultureInfo.InvariantCulture);
var salt = "randomSalt";
var hash = "ranomdHash";
var creatorUser = new DatabaseModel.User("steamId", "name", "imageURl", null, DateTime.Today, DateTime.Today, false, null, 10);
var gameMode = new DatabaseModel.GameMode
{
CurrentSettingId = 1,
IsEnabled = true,
Type = GameModeHelper.GetStringFromType(GameModeType.CoinFlip),
Id = 2
};
A.CallTo(() => _fakedMongoDbPreHashRepoService.Find(hash, creatorUser.SteamId)).Returns(new MongoDbModels.PreHash
{
Created = DateTime.Today,
Hash = hash,
Percentage = percentageAsString,
Salt = salt,
UserSteamId = creatorUser.SteamId
});
A.CallTo(() => _fakedRandomService.GenerateNewGuidAsString()).Returns("GUID");
A.CallTo(() => _fakedJackpotSettingRepoService.InsertAsync(A <DatabaseModel.JackpotSetting> ._, A <ITransactionWrapper> ._))
.Returns(new DatabaseModel.JackpotSetting {
Id = 1
});
A.CallTo(() => _fakedUserRepoService.FindAsync(creatorUser.SteamId)).Returns(creatorUser);
A.CallTo(() => _fakedGameModeRepoSerivce.Find(GameModeHelper.GetStringFromType(GameModeType.CoinFlip))).Returns(gameMode);
var itemList = new List <AssetAndDescriptionId>
{
new AssetAndDescriptionId {
AssetId = "assetId1", DescriptionId = 1
}
};
await _coinFlipService.CreateMatch(creatorUser.SteamId, true, itemList, _defaultSetting);
A.CallTo(() => _fakedCoinFlipMatchRepoService.InsertAsync(A <DatabaseModel.CoinFlip> .That.Matches
(m =>
m.Created > DateTime.Today &&
m.CreatorUserId == 10 &&
m.CreatorIsHead == true &&
m.Hash == hash &&
m.Salt == salt &&
m.Percentage == percentageAsString &&
m.RoundId == "GUID" &&
m.Status == (int)MatchStatus.Open &&
m.TimerStarted == null &&
m.WinnerId == null &&
m.GameModeId == 2 &&
m.SettingId == 1
),
A <ITransactionWrapper> ._
)).MustHaveHappened();
A.CallTo(() => _fakedMongoDbPreHashRepoService.Find(hash, creatorUser.SteamId)).MustHaveHappened();
A.CallTo(() => _fakedUserRepoService.FindAsync(creatorUser.SteamId)).MustHaveHappened();
A.CallTo(() => _fakedTransactionWrapper.Commit()).MustHaveHappened();
A.CallTo(() => _fakedBetService.PlaceBetOnCoinFlipMatch
(
A <DatabaseModel.CoinFlip> ._,
A <JackpotMatchSetting> ._,
A <DatabaseModel.GameMode> ._,
A <int> ._,
A <List <DatabaseModel.Item> > ._,
A <DatabaseModel.User> ._,
A <List <DatabaseModel.ItemDescription> > ._
)).MustHaveHappened();
A.CallTo(() => _fakedMongoDbJackpotRepoService.InsertAsync(A <MongoDbModels.JackpotMatch> ._)).MustHaveHappened();
}
public RakeServiceTest()
{
_winningUser = new DatabaseModel.User("winnerSteamId", "", "", "", DateTime.Now, DateTime.Now, false, null, 1);
}
public Task <List <DatabaseModel.Bet> > GetBetsFromUser(DatabaseModel.User user, int limit, int?from)
{
return(_betRepoService.FindAsync(user, limit, from));
}
public Task <List <DatabaseModel.Bet> > GetBetsFromUser(DatabaseModel.User user)
{
return(_betRepoService.FindAsync(user));
}
private async Task <List <MatchHistory> > GetMatchHistories(DatabaseModel.User user, List <DatabaseModel.Match> matches)
{
var matchHistory = new List <MatchHistory>();
foreach (var match in matches)
{
decimal matchValue = 0;
decimal userValue = 0;
var itemsInPot = 0;
var bettedItemsOnMatch = await _betService.GetBettedItemsOnMatch(match.Id, match.GameModeId);
itemsInPot = bettedItemsOnMatch.Count;
if (!match.WinnerId.HasValue)
{
throw new Exception("Something is badly wrong! No winnerid on closed match!!!!");
}
var matchWinner = await _repoServiceFactory.UserRepoService.FindAsync(match.WinnerId.Value);
foreach (var item in bettedItemsOnMatch)
{
matchValue += item.Value;
if (item.Owner.SteamId == user.SteamId)
{
userValue += item.Value;
}
}
matchHistory.Add(new MatchHistory
{
Created = match.Created,
Hash = match.Hash,
Percentage = match.Percentage,
RoundId = match.RoundId,
Salt = match.Salt,
MatchValue = matchValue,
UserValue = userValue,
ItemsInMatch = itemsInPot,
WinnerSteamId = matchWinner.SteamId
});
}
return(matchHistory);
//
// var winnerSteamIds = new List<int>();
// foreach (var match in matches)
// {
// if (!match.WinnerId.HasValue) ;
// winnerSteamIds.Add(match.WinnerId.Value);
// }
// var winners = await _repoServiceFactory.UserRepoService.FindAsync(winnerSteamIds);
//
//
// if (matches.Count != bets.Count)
// throw new Exception($"Matches won does not equal bets somehow?{matches.Count}-{bets.Count}"); //This should never happen!
//
// for (var i = 0; i < matches.Count; i++)
// {
// var match = matches[i];
// var betId = bets[i];
// decimal value = 0;
//
// int nrOfItemsBetted = 0;
// foreach (var itemBetted in itemsBetted)
// {
// if (betId != itemBetted.BetId) continue;
// value += itemBetted.Value;
// nrOfItemsBetted++;
// }
//
// matchHistory.Add(new MatchHistory
// {
// Created = match.Created,
// Hash = match.Hash,
// Percentage = match.Percentage,
// RoundId = match.RoundId,
// Salt = match.Salt,
// MatchValue = value,
// NrOfItemsBetted = nrOfItemsBetted,
// WinnerSteamId = winners.First(u=> match.WinnerId != null && u.Id == match.WinnerId.Value).SteamId
// });
// }
//
// return matchHistory;
}
private bool PromotionInName(DatabaseModel.User winner)
{
var name = winner.Name.ToLower();
return(name.Contains("DomainName.com") || name.Contains("DomainName"));
}
public async Task <IActionResult> RandomUserBetsOnCoinFlip(int lookUpId, int nrOfSkins = 5)
{
if (nrOfSkins <= 0)
{
return(BadRequest("NrOfSkins needs to be grater than 0"));
}
if (nrOfSkins > 10)
{
return(BadRequest("NrOfSkins needs to be CAN'T be grater than 10"));
}
var user = await _repoServiceFactory.UserRepoService.FindAsync("randomSteamId");
var itemDesc = await _repoServiceFactory.ItemDescriptionRepoService.FindAsync("Chroma 2 case");
if (user == null)
{
var insertUser = new DatabaseModel.User("randomSteamId", "Rip skins", "b2/b2f83f910fe134cd063357c0a90517ce224a4c04", "Tradelnik",
DateTime.Now,
DateTime.Now,
false);
user = await _repoServiceFactory.UserRepoService.InsertAsync(insertUser);
}
var bots = await _repoServiceFactory.BotRepoService.GetAll();
var botId = bots.First().Id;
for (int i = 0; i < nrOfSkins; i++)
{
}
var random1 = RandomString(10);
var random2 = RandomString(10);
var random3 = RandomString(10);
var random4 = RandomString(10);
try
{
await _repoServiceFactory.ItemRepoService.InsertAsync(new DatabaseModel.Item(random1, itemDesc.Id, botId, user.Id, DateTimeOffset.Now));
await _repoServiceFactory.ItemRepoService.InsertAsync(new DatabaseModel.Item(random2, itemDesc.Id, botId, user.Id, DateTimeOffset.Now));
await _repoServiceFactory.ItemRepoService.InsertAsync(new DatabaseModel.Item(random3, itemDesc.Id, botId, user.Id, DateTimeOffset.Now));
await _repoServiceFactory.ItemRepoService.InsertAsync(new DatabaseModel.Item(random4, itemDesc.Id, botId, user.Id, DateTimeOffset.Now));
}
catch (System.Exception e)
{
// ignored
}
_coinFlipManager.PlaceBet(new List <AssetAndDescriptionId>
{
new AssetAndDescriptionId {
AssetId = random1, DescriptionId = itemDesc.Id
},
new AssetAndDescriptionId {
AssetId = random2, DescriptionId = itemDesc.Id
},
new AssetAndDescriptionId {
AssetId = random3, DescriptionId = itemDesc.Id
},
new AssetAndDescriptionId {
AssetId = random4, DescriptionId = itemDesc.Id
},
}, lookUpId, user.SteamId);
return(Ok());
}
public async Task <DatabaseModel.User> InsertAsync(string steamId, string name, string imgUrl)
{
var user = new DatabaseModel.User(steamId, name, imgUrl, null, DateTime.Now, DateTime.Now, false);
return(await InsertAsync(user));
}
public async void TestForBetsJackpotAndOnCoinFlip()
{
var user = new DatabaseModel.User("steamId", "name", "imageUrl", "tradelink", DateTime.Now, DateTime.Now, false, null, 9);
A.CallTo(() => _itemRepoService.FindAsync(A <DatabaseModel.User> ._)).Returns(new List <DatabaseModel.Item>
{
new DatabaseModel.Item("assetId1", 1, -1, 9, DateTimeOffset.Now, 10),
new DatabaseModel.Item("assetId2", 1, -1, 9, DateTimeOffset.Now, 11),
new DatabaseModel.Item("assetId3", 2, -1, 9, DateTimeOffset.Now, 12),
new DatabaseModel.Item("assetId4", 3, -1, 9, DateTimeOffset.Now, 13),
new DatabaseModel.Item("assetId5", 3, -1, 9, DateTimeOffset.Now, 13),
new DatabaseModel.Item("assetId6", 3, -1, 9, DateTimeOffset.Now, 13),
});
A.CallTo(() => _descriptionRepoService.FindAsync(A <List <int> > ._)).Returns(new List <DatabaseModel.ItemDescription>
{
new DatabaseModel.ItemDescription("itemDesc1", 1, "730", "2", "img1", true, 1),
new DatabaseModel.ItemDescription("itemDesc2", 1, "730", "2", "img1", true, 2),
new DatabaseModel.ItemDescription("itemDesc3", 1, "730", "2", "img1", true, 3)
});
var match = new DatabaseModel.Match(1, "salt", "hash", 14.4.ToString(CultureInfo.InvariantCulture), 1, null, null, 1, 1, DateTime.Now, 1);
var bets = new List <DatabaseModel.Bet>
{
new DatabaseModel.Bet(10, 1, 1, DateTime.Now, 11),
new DatabaseModel.Bet(9, 1, 2, DateTime.Now, 11)
};
A.CallTo(() => _itemBettedRepoSerivce.FindAsync(A <List <DatabaseModel.Bet> > ._)).Returns(new List <DatabaseModel.ItemBetted>
{
new DatabaseModel.ItemBetted(bets[0].Id, 1, "assetId1", 1),
new DatabaseModel.ItemBetted(bets[0].Id, 3, "assetId4", 1),
});
A.CallTo(() => _matchRepoService.GetCurrentMatch()).Returns(match);
A.CallTo(() => _betRepoService.FindAsync(A <List <LookUpGameModeBet> > ._)).Returns(bets);
A.CallTo(() => _fakedCoinFlipService.FindAllNotClosedMatches()).Returns(new List <DatabaseModel.CoinFlip>
{
new DatabaseModel.CoinFlip
{
Created = DateTime.Today,
CreatorIsHead = false,
CreatorUserId = 9,
GameModeId = 1,
Hash = "hash",
Salt = "salt",
Id = 1,
Percentage = "",
RoundId = "",
SettingId = 0,
Status = 1,
TimerStarted = null,
WinnerId = null
},
new DatabaseModel.CoinFlip
{
Created = DateTime.Today,
CreatorIsHead = false,
CreatorUserId = 10,
GameModeId = 1,
Hash = "hash",
Salt = "salt",
Id = 1,
Percentage = "",
RoundId = "",
SettingId = 0,
Status = 1,
TimerStarted = null,
WinnerId = null
}
});
var itemService = new ItemService(_fakedRepoService);
var avalibleItemsForUser = await itemService.GetAvalibleItemsForUser(user);
A.CallTo(() => _fakedCoinFlipService.FindAllNotClosedMatches()).MustHaveHappened();
Assert.Equal(4, avalibleItemsForUser.Count);
Assert.Equal("itemDesc3", avalibleItemsForUser.Single(item => item.AssetId == "assetId5").Name);
Assert.Equal("itemDesc3", avalibleItemsForUser.Single(item => item.AssetId == "assetId6").Name);
Assert.Equal("itemDesc2", avalibleItemsForUser.Single(item => item.AssetId == "assetId3").Name);
Assert.Equal("itemDesc1", avalibleItemsForUser.Single(item => item.AssetId == "assetId2").Name);
}
public async Task <int> ChangeOwner(int itemId, DatabaseModel.User user)
{
var query = _itemQueries.ChangeOwner(itemId, user.Id);
return(await _databaseConnection.ExecuteNonQueryAsync(query));
}
public async Task <int> ChangeOwner(DatabaseModel.Item item, DatabaseModel.User user)
{
return(await ChangeOwner(item.Id, user));
}
public async Task <List <DatabaseModel.CoinFlip> > FindAllOpenOrDraftingMatchesMatchs(DatabaseModel.User user)
{
return(await _repoServiceFactory.CoinFlipMatchRepoService.FindAllOpenMatchesAsync(user));
}
public async Task AddWinnerToMatch(DatabaseModel.User winner, int matchRoundId)
{
var query = _matchQueries.AddWinner(winner.Id, matchRoundId);
await _databaseConnection.ExecuteNonQueryAsync(query);
}
public async Task TimmerRanOutForMatchDraftsWinnerSuccess()
{
var manager = new CoinFlipManager
(
_fakedRepoServiceFactory,
_fakedCoinFlipService,
_fakedDraftingService,
_coinFlipSocketSender,
_dummyBetOrWithdrawQueueManager,
_dummyBetHubConnection,
_dummyLogServiceFactory,
_dummyBetService,
_dummyMongoJackpotRepoService,
_dummyHotStatusManager,
_dummyDiscordService
);
var bets = new List <DatabaseModel.Bet>
{
new DatabaseModel.Bet(10, 1, 2, DateTime.Today),
new DatabaseModel.Bet(9, 1, 2, DateTime.Today),
};
var winningUser = new DatabaseModel.User("", "", "", "", DateTime.Now, DateTime.Now, false, null, 10);
A.CallTo(() => _fakedBetRepoService.FindAsync(1, 2)).Returns(Task.FromResult(bets));
A.CallTo(() => _fakedCoinFlipMatchRepoService.FindAllNotClosedMatches()).Returns(new List <DatabaseModel.CoinFlip>
{
new DatabaseModel.CoinFlip
{
Created = DateTime.Now,
CreatorIsHead = true,
CreatorUserId = 10,
GameModeId = 2,
Hash = "hash",
Id = 1,
Percentage = "5",
RoundId = "",
Salt = "",
SettingId = 5,
Status = (int)MatchStatus.TimerCountdown,
TimerStarted = DateTime.Today,
WinnerId = null
}
});
A.CallTo(() => _fakedDraftingService.GetWinningBet(5, bets, A <List <DatabaseModel.ItemBetted> > ._)).Returns(new WinningBet
{
Bet = bets[0],
WinningTicket = 5
});
A.CallTo(() => _fakedJackpotSettingRepo.Find(5)).Returns(new DatabaseModel.JackpotSetting
{
Rake = 10
});
A.CallTo(() => _fakedUserRepoService.FindAsync(10)).Returns(winningUser);
await ExecuteStartStopManager(manager);
A.CallTo(() => _fakedCoinFlipMatchRepoService.FindAllNotClosedMatches()).MustHaveHappened();
A.CallTo(() => _fakedBetRepoService.FindAsync(1, 2)).MustHaveHappened();
A.CallTo(() => _fakedJackpotSettingRepo.Find(5)).MustHaveHappened();
A.CallTo(() => _fakedCoinFlipMatchRepoService.UpdateAsync(A <DatabaseModel.CoinFlip> .That.Matches(
m =>
m.Created > DateTime.Today &&
m.CreatorIsHead == true &&
m.CreatorUserId == 10 &&
m.GameModeId == 2 &&
m.Hash == "hash" &&
m.Id == 1 &&
m.Percentage == "5" &&
m.RoundId == "" &&
m.Salt == "" &&
m.SettingId == 5 &&
m.Status == (int)MatchStatus.TimerCountdown &&
m.TimerStarted >= DateTime.Today &&
m.WinnerId == null
)
)).MustNotHaveHappened();
A.CallTo(() => _fakedCoinFlipMatchRepoService.UpdateAsync(A <DatabaseModel.CoinFlip> .That.Matches(
m =>
m.Created > DateTime.Today &&
m.CreatorIsHead == true &&
m.CreatorUserId == 10 &&
m.GameModeId == 2 &&
m.Hash == "hash" &&
m.Id == 1 &&
m.Percentage == "5" &&
m.RoundId == "" &&
m.Salt == "" &&
m.SettingId == 5 &&
m.Status == (int)MatchStatus.Drafting &&
m.TimerStarted >= DateTime.Today &&
m.WinnerId == 10
)
)).MustHaveHappened();
A.CallTo(() => _fakedDraftingService.GetWinningBet(5, bets, A <List <DatabaseModel.ItemBetted> > ._)).MustHaveHappened();
A.CallTo(() => _fakedUserRepoService.FindAsync(10)).MustHaveHappened();
A.CallTo(() => _fakedDraftingService.ChangeOwnerOfItems(bets, A <List <DatabaseModel.ItemBetted> > ._, winningUser, 1, 10, 2))
.MustHaveHappened();
}
private static async Task SendItems(DatabaseModel.User user, List <AssetAndDescriptionId> itemsToSend, DatabaseModel.User userToSendFrom)
{
await IoC.Container.Resolve <IItemTransferService>().TransferItemsAsync(userToSendFrom, user.SteamId, itemsToSend);
}
public async Task ChangeOwnerOfItemsSuccess()
{
var matchId = 1;
decimal rake = 10;
var gameModeId = 2;
var winningUserId = 1337;
var bets = new List <DatabaseModel.Bet>();
var items = new List <DatabaseModel.ItemBetted>();
var winningUser = new DatabaseModel.User("steamId", "name", "img", "tradelin", DateTime.Now, DateTime.Now, false, null, winningUserId);
A.CallTo(() => _fakedRakeService.GetItemsThatWeShouldTake(rake, bets, items, winningUser)).Returns(new RakeService.RakeResult
{
ItemIdsToUs = new List <AssetAndDescriptionId>
{
new AssetAndDescriptionId
{
AssetId = "1",
DescriptionId = 2,
}
},
ItemIdsToWinner = new List <AssetAndDescriptionId>
{
new AssetAndDescriptionId
{
AssetId = "2",
DescriptionId = 2,
},
new AssetAndDescriptionId
{
AssetId = "3",
DescriptionId = 2,
},
new AssetAndDescriptionId
{
AssetId = "4",
DescriptionId = 2,
},
}
});
A.CallTo(() => _fakedItemRepoService.FindAsync(A <List <AssetAndDescriptionId> > ._)).Returns(new List <DatabaseModel.Item>
{
new DatabaseModel.Item("1", 2, 3, 5, DateTimeOffset.Now)
});
await _service.ChangeOwnerOfItems(bets, items, winningUser, matchId, rake, gameModeId);
A.CallTo(() => _fakedItemRepoService.ChangeOwner(A <List <AssetAndDescriptionId> > .That.Matches(list => list.Count == 3), winningUser)).MustHaveHappened();
A.CallTo(() => _fakedRakeItemRepoService.InsertAsync(A <List <DatabaseModel.RakeItem> > .That.Matches(
list =>
list.Count == 1 &&
list[0].AssetId == "1" &&
list[0].DescriptionId == 2 &&
list[0].GameModeId == gameModeId &&
list[0].MatchId == matchId
), null)).MustHaveHappened();
A.CallTo(() => _fakedRakeItemRepoService.InsertAsync(A <List <DatabaseModel.RakeItem> > .That.Matches(list =>
list.Count == 1 &&
list[0].AssetId == "1" &&
list[0].DescriptionId == 2
), null
)).MustHaveHappened();
A.CallTo(() => _fakedRakeService.GetItemsThatWeShouldTake(rake, bets, items, winningUser)).MustHaveHappened();
}
public Task <List <int> > GetBetsForUserOnMatches(DatabaseModel.User user, List <int> matchIds, int gameModeId)
{
return(_betRepoService.FindAsync(user, matchIds, gameModeId));
}
private async Task BetSkinsForUser(DatabaseModel.ItemDescription itemDesc, int botId, DatabaseModel.User user, int roundId, int nrOfSkins)
{
var insertedItems = new List <string>();
for (int i = 0; i < nrOfSkins; i++)
{
var randomAssetId = RandomString(10);
try
{
await _repoServiceFactory.ItemRepoService.InsertAsync(new DatabaseModel.Item(randomAssetId, itemDesc.Id, botId, user.Id, DateTimeOffset.Now));
insertedItems.Add(randomAssetId);
}
catch (System.Exception)
{
// ignored
}
}
var itemsToBet = insertedItems.Select(assetId => new AssetAndDescriptionId {
AssetId = assetId, DescriptionId = itemDesc.Id
}).ToList();
_jackpotMatchManager.PlaceBetOnMatch(itemsToBet, roundId, user.SteamId);
}
private async Task PlaceBetOnMatch
(
int matchId,
JackpotMatchSetting setting,
DatabaseModel.GameMode gameMode,
int assetAndDescriptionIdsCount,
List <DatabaseModel.Item> items,
DatabaseModel.User user,
List <DatabaseModel.ItemDescription> uniqueItemDescriptions
)
{
if (!gameMode.IsEnabled)
{
throw new GameModeIsNotEnabledException($"The current gamemode {gameMode.Type} is not enabled");
}
if ((setting.AllowCsgo && setting.AllowPubg) == false)
{
var oneOrMoreItemsIsPubg = uniqueItemDescriptions.Any(AppIdToGameConverterHelper.IsPubgItem);
var oneOrMoreItemsIsCsgo = uniqueItemDescriptions.Any(AppIdToGameConverterHelper.IsCsgoItem);
if (setting.AllowCsgo && oneOrMoreItemsIsPubg)
{
throw new NotAllowedAppIdOnMatchException("You tried to bet a PUBG item on a match that only accepts CSGO");
}
if (setting.AllowPubg && oneOrMoreItemsIsCsgo)
{
throw new NotAllowedAppIdOnMatchException("You tried to bet a CSGO item on a match that only accepts PUBG");
}
}
if (uniqueItemDescriptions.Any(description => !description.Valid))
{
throw new InvalidItemException("One or more items is not allowed to be used for betting at the moment, refresh the page and try again");
}
if (user == null)
{
throw new UserDoesNotExistException("Can't find a user");
}
if (items.Any(item => item.OwnerId != user.Id))
{
throw new UserDoesNotOwnThisItemsException("The user does not own this item!");
}
if (items.Count == 0)
{
throw new InvalidAssetAndDecriptionIdException("No items with that assetId or descriptionId was found");
}
if (items.Count != assetAndDescriptionIdsCount)
{
throw new NotSameCountAsExpectedException("assetAndDescriptionIds count != avalibleItems");
}
if (items.Count > setting.MaxItemAUserCanBet)
{
throw new ToManyItemsOnBetException($"You can max bet {setting.MaxItemAUserCanBet} items, you tried to bet {items.Count}");
}
if (items.Count < setting.MinItemAUserCanBet)
{
throw new ToFewItemsOnBetException($"You can min bet {setting.MinItemAUserCanBet} items, you tried to bet {items.Count}");
}
var sumOfBet = await _itemService.GetSumOfItems(items);
if (sumOfBet > setting.MaxValueAUserCanBet)
{
throw new ToMuchValueOnBetException($"You can max bet {setting.MaxValueAUserCanBet} value, you tried to bet {sumOfBet}");
}
if (sumOfBet < setting.MinValueAUserCanBet)
{
throw new ToLittleValueOnBetException($"You can min bet {setting.MinValueAUserCanBet} value, you tried to bet {sumOfBet}");
}
var avalibleItems = await _itemService.GetAvalibleItemsForUser(user);
if (avalibleItems.Count == 0)
{
throw new NoAvalibleItemsForBettingException("No avalible item for betting");
}
if (IsSameItemsInAvalibleItemsAsInItem(items, avalibleItems))
{
throw new ItemNotAvalibleException("This item can not be betted now! Is this items already betted on an open match?)");
}
await InsertBetWithTransaction(user, matchId, items, gameMode, uniqueItemDescriptions);
//we have now successfully placed a bet
if (gameMode.Type == GameModeHelper.GetStringFromType(GameModeType.JackpotCsgo))
{
_discordService.JackpotBetAsync(matchId, user.SteamId, sumOfBet);
}
}
public async Task <List <Item> > GetAvalibleItemsForUser(DatabaseModel.User user)
{
var jackpotGameModeTask = _gameModeRepoService.Find(GameModeHelper.GetStringFromType(GameModeType.JackpotCsgo));
var coinFlipGameModeTask = _gameModeRepoService.Find(GameModeHelper.GetStringFromType(GameModeType.CoinFlip));
var currentMatchTask = _matchRepoService.GetCurrentMatch();
var notClosedCoinFlipmatchesTask = _coinFlipMatchRepoService.FindAllNotClosedMatches();
await Task.WhenAll(jackpotGameModeTask, coinFlipGameModeTask, currentMatchTask, notClosedCoinFlipmatchesTask);
var coinFlipGameMode = coinFlipGameModeTask.Result;
var currentMatch = currentMatchTask.Result;
var jackpotGameMode = jackpotGameModeTask.Result;
var notClosedCoinFlipmatches = notClosedCoinFlipmatchesTask.Result;
var coinflipLookUpGameModeBet = new LookUpGameModeBet
{
GameMode = coinFlipGameMode,
User = user,
MatchIds = notClosedCoinFlipmatches.Select(coin => coin.Id).ToList()
};
var jackpotLookUpGameModeBet = new LookUpGameModeBet
{
GameMode = jackpotGameMode,
User = user,
MatchIds = new List <int> {
currentMatch.Id
}
};
var userBets = await _betRepoService.FindAsync(new List <LookUpGameModeBet>
{
coinflipLookUpGameModeBet,
jackpotLookUpGameModeBet
});
var offers = await _offerTransactionRepoService.FindActiveAsync(user);
var itemThatUserOwns = await GetItemsThatUsersOwns(user);
if (userBets.Count == 0 && offers.Count == 0)
{
return(itemThatUserOwns);
}
if (userBets.Count > 0 && offers.Count == 0)
{
return(await GetNoneBetedItems(userBets, itemThatUserOwns));
}
if (userBets.Count == 0 && offers.Count > 0)
{
return(await GetItemsThatIsNotInAOffer(offers, itemThatUserOwns));
}
var itemNotInOffer = await GetItemsThatIsNotInAOffer(offers, itemThatUserOwns);
var itemNotInBetAndNotInOffer = await GetNoneBetedItems(userBets, itemNotInOffer);
return(itemNotInBetAndNotInOffer);
}
public async Task <bool> UpdateUserInfoIfNeeded(DatabaseModel.User newUserInfo, DatabaseModel.User user)
{
var userRepoService = _repoServiceFactory.UserRepoService;
if (user.ImageUrl != newUserInfo.ImageUrl && user.Name != newUserInfo.Name)
{
await userRepoService.UpdateImageAndNameAsync(user.SteamId, newUserInfo.Name, newUserInfo.ImageUrl);
return(false);
}
if (user.ImageUrl != newUserInfo.ImageUrl)
{
await userRepoService.UpdateImageAsync(user.SteamId, newUserInfo.ImageUrl);
}
if (user.Name != newUserInfo.Name)
{
await userRepoService.UpdateNameAsync(user.SteamId, newUserInfo.Name);
}
return(false);
}
