public async Task BanlistCommand(Banlist input)
{
var format = input switch
{
Banlist.Ocg => BanlistFormats.OCG,
Banlist.TcgAdv => BanlistFormats.TCG,
Banlist.TcgTrad => BanlistFormats.TRAD,
_ => throw new ArgumentOutOfRangeException(nameof(input), input, null)
};
var banlist = await YuGiOhDbService.GetBanlistAsync(format);
if (banlist.Forbidden.Any())
{
await DirectMessageAsync(FormatBanlist("Forbidden", banlist.Forbidden));
}
if (banlist.Limited.Any())
{
await DirectMessageAsync(FormatBanlist("Limited", banlist.Limited));
}
if (banlist.SemiLimited.Any())
{
await DirectMessageAsync(FormatBanlist("Semi-Limited", banlist.SemiLimited));
}
await RespondAsync("The banlist has been directly messaged to you");
}
/// <inheritdoc />
public bool CanDeckBeUsedOnGivenBanlist(Decklist decklist, Banlist banlist)
{
var countedCards = _countCards(decklist);
bool isForbiddenCardInDecklist = _deckContainsNotAllowedCards(
banlist.ForbiddenCards,
countedCards,
(card, countedCard) => { return(true); });
bool isMoreThanOneCopyOfLimitedCardInDeck = _deckContainsNotAllowedCards(
banlist.LimitedCards,
countedCards,
(card, countedCard) =>
{
return(countedCard.NumberOfCopies > 1);
});
bool isMoreThanTwoCopiesOfSemiLimitedCardInDeck = _deckContainsNotAllowedCards(
banlist.SemiLimitedCards,
countedCards,
(card, countedCard) =>
{
return(countedCard.NumberOfCopies > 2);
});
return(!isForbiddenCardInDecklist &&
!isMoreThanOneCopyOfLimitedCardInDeck &&
!isMoreThanTwoCopiesOfSemiLimitedCardInDeck);
}
private void _ifThereIsAnyBanlistAddItToDbContext(Banlist banlist)
{
if (banlist != null)
{
_db.Banlists.Add(banlist);
}
}
private int _howManyTimesWasUsedInRange(Banlist banlist, DateTime?statisticsFrom, DateTime?statisticsTo)
{
if (statisticsFrom != null && statisticsTo == null)
{
return(banlist
.Statistics
.Where(x => x.DateWhenBanlistWasUsed >= statisticsFrom)
.Sum(x => x.HowManyTimesWasUsed));
}
else
if (statisticsFrom == null && statisticsTo != null)
{
return(banlist
.Statistics
.Where(x => x.DateWhenBanlistWasUsed <= statisticsTo)
.Sum(x => x.HowManyTimesWasUsed));
}
else if (statisticsFrom != null && statisticsTo != null)
{
return(banlist
.Statistics
.Where(x => x.DateWhenBanlistWasUsed >= statisticsFrom && x.DateWhenBanlistWasUsed <= statisticsTo)
.Sum(x => x.HowManyTimesWasUsed));
}
else
{
return(banlist
.Statistics
.Sum(x => x.HowManyTimesWasUsed));
}
}
public async Task DeckContainsBetaCard_OfficialIDAppears_ConvertCardToOfficial()
{
using (var dbInMemory = new YgoProAnalyticsDatabase(_getOptionsForSqlInMemoryTesting <YgoProAnalyticsDatabase>()))
{
dbInMemory.Database.EnsureCreated();
_addPSYFrameDriver(dbInMemory);
_addMokeyMokeyKing(dbInMemory);
_addChecksumDragon(dbInMemory);
_addPankratops(dbInMemory);
var banlist = new Banlist("2019.10 TCG", 1);
banlist.ForbiddenCards.Add(_checksumDragon);
dbInMemory.Banlists.Add(banlist);
await dbInMemory.SaveChangesAsync();
var decklist = _converterMock.Object.Convert(GetProperYDKString());
decklist.Name = "Lunalight";
decklist.Archetype = _defaultArchetype;
dbInMemory.Decklists.Add(decklist);
await dbInMemory.SaveChangesAsync();
IBetaCardToOfficialConverter _converter = new BetaCardToOfficialConverter(dbInMemory, _adminConfigMock.Object, _downloaderMock.Object);
await _converter.UpdateCardsFromBetaToOfficial();
var decklistFromDb = dbInMemory.Decklists.First();
Assert.Multiple(() =>
{
//tests if a beta card (Cheksum dragon with betaid:100336006) is converted to 94136469
Assert.IsNotNull(decklistFromDb.MainDeck.FirstOrDefault(x => x.PassCode == 94136469));
Assert.IsNull(decklistFromDb.MainDeck.FirstOrDefault(x => x.PassCode == 100336006));
});
}
}
public void Initialize(string BanListLoc)
{
if (File.Exists(BanListLoc))
{
var ConfigLoader = new XmlSerializer(typeof(Banlist));
StreamReader ConfigReader = File.OpenText(BanListLoc);
var Config = (Banlist)ConfigLoader.Deserialize(ConfigReader);
ConfigReader.Close();
banlist = Config;
banListFile = BanListLoc;
LogManager.Log("Banlist loaded. " + banlist.List.Count.ToString() + " ban" +
(banlist.List.Count != 1 ? "s." : "."));
}
else
{
if (LogManager.Singleton != null)
{
LogManager.Log("No Banlist found. Creating Empty List (" + BanListLoc + ")");
}
banlist = new Banlist();
banlist.List.Add(new BanEntry());
banListFile = BanListLoc;
Save();
}
}
private void BuildList(Banlist banList)
{
int yOffset = 40;
foreach (BanEntry entry in banList.List)
{
var line = new Label("IP: " + entry.ip + "\tReason: " + entry.reason +
"\tTemporary: " + entry.tempBan + "\tExpires: " +
entry.expiresAt.ToString("d/M/yyyy HH:mm:ss"), "CALIBRI", _resourceManager)
{
Position = new Vector2i(5, yOffset + 5)
};
components.Add(line);
var unbanButton = new Button("Unban", _resourceManager)
{
Position =
new Vector2i(line.ClientArea.Right() + 10,
yOffset + (int)(line.ClientArea.Height / 3f))
};
components.Add(unbanButton);
unbanButton.UserData = entry.ip;
unbanButton.Clicked += UnbanButtClicked;
unbanButton.Update(0);
yOffset += 35;
}
}
public async Task <Banlist> Update(Banlist banlist)
{
banlist.Updated = DateTime.UtcNow;
_context.Banlist.Update(banlist);
await _context.SaveChangesAsync();
return(banlist);
}
/// <inheritdoc />
public BanlistWithStatisticsDTO Convert(Banlist banlistToConvert)
{
return(new BanlistWithStatisticsDTO(
name: banlistToConvert.Name,
format: banlistToConvert.Format,
releaseDate: banlistToConvert.ReleaseDate,
bannedCards: _decksDtosFactory.CreateDeckDto(banlistToConvert.ForbiddenCards),
limitedCards: _decksDtosFactory.CreateDeckDto(banlistToConvert.LimitedCards),
semiLimitedCards: _decksDtosFactory.CreateDeckDto(banlistToConvert.SemiLimitedCards),
statistics: _getBanlistStatisticsDtos(banlistToConvert)
));
}
/// <inheritdoc />
public async Task <IEnumerable <Banlist> > UpdateBanlists(string url)
{
_banlists = _db.Banlists.ToList();
List <Card> cards = _db.Cards.ToList();
string banlistDataAsString = await _banlistDataDownloader.DownloadBanlistFromWebsite(url);
var banlistDatas = banlistDataAsString.Replace("\r", String.Empty).Split("\n");
List <Banlist> newBanlists = new List <Banlist>();
Banlist banlist = null;
for (int i = 1; i < banlistDatas.Length; i++)
{
var line = banlistDatas[i];
if (line.Length == 0)
{
continue;
}
if (_isInformationAboutBanlistName(line))
{
_ifThereIsAnyBanlistAddItToDbContext(banlist);
string banlistName = line.Substring(1);
if (_isBanlistAlreadyInDatabase(banlistName))
{
continue;
}
banlist = new Banlist(banlistName, _banlistNumberInLflist);
newBanlists.Add(banlist);
continue;
}
_checkIfWeAnalyzeForbiddenOrLimitedOrSemiLimitedCards(line);
if (banlist != null && !_isInformationAboutCardCountLimitations(line))
{
int cardPassCode = int.Parse(line.Substring(0, line.IndexOf(' ')));
var card = cards
.FirstOrDefault(x => x.PassCode == cardPassCode);
if (card == null)
{
continue;
}
_addCardToAppropriateBanlistSection(banlist, card);
}
}
_ifThereIsAnyBanlistAddItToDbContext(banlist);
await _db.SaveChangesAsync();
return(newBanlists);
}
private List <BanlistStatisticsDTO> _getBanlistStatisticsDtos(Banlist banlistToConvert)
{
var statistics = new List <BanlistStatisticsDTO>();
foreach (var statistic in banlistToConvert.Statistics)
{
statistics.Add(new BanlistStatisticsDTO(
statistic.DateWhenBanlistWasUsed,
statistic.HowManyTimesWasUsed));
}
return(statistics);
}
private void _analyzeBanlist(DuelLog duelLog)
{
Banlist banlist = _duelLogNameAnalyzer.GetBanlist(duelLog.Name, duelLog.DateOfTheBeginningOfTheDuel.Date);
var banlistStatistics = banlist.Statistics.FirstOrDefault(x => x.DateWhenBanlistWasUsed == duelLog.DateOfTheBeginningOfTheDuel.Date);
if (banlistStatistics == null)
{
banlistStatistics = BanlistStatistics.Create(duelLog.DateOfTheBeginningOfTheDuel.Date, banlist);
banlist.Statistics.Add(banlistStatistics);
}
banlistStatistics.IncrementHowManyTimesWasUsed();
}
public void SetUp()
{
_decksDtosFactory = new Mock <IDecksDtosFactory>();
_converter = new BanlistToBanlistDTOConverter(_decksDtosFactory.Object);
_banlist = new Banlist("2019.11 TCG", 1);
var statistics1 = BanlistStatistics.Create(new DateTime(2020, 4, 29), _banlist);
statistics1.IncrementHowManyTimesWasUsed();
var statistics2 = BanlistStatistics.Create(new DateTime(2020, 4, 30), _banlist);
statistics2.IncrementHowManyTimesWasUsed();
statistics2.IncrementHowManyTimesWasUsed();
_banlist.Statistics.Add(statistics1);
_banlist.Statistics.Add(statistics2);
}
private void _addCardToAppropriateBanlistSection(Banlist banlist, Card card)
{
if (_areUpdatedForbiddenCardsNow && !banlist.ForbiddenCards.Contains(card))
{
banlist.ForbiddenCards.Add(card);
}
else if (_areUpdatedLimitedCardsNow && !banlist.LimitedCards.Contains(card))
{
banlist.LimitedCards.Add(card);
}
else if (_areUpdatedSemiLimitedCardsNow && !banlist.SemiLimitedCards.Contains(card))
{
banlist.SemiLimitedCards.Add(card);
}
}
public void CanDeckBeUsedOnGivenBanlist_DeckCanBeUsed_ReturnsTrue()
{
var mainDeck = _generateSimplifiedDeckOfCards(40);
var extraDeck = _generateSimplifiedDeckOfCards(15);
var sideDeck = _generateSimplifiedDeckOfCards(15);
Decklist decklist = _genereateDecklistWithAllRequiredData(mainDeck, extraDeck, sideDeck);
var banlist = new Banlist("2018.05 TCG", 1);
_db.Decklists.Add(decklist);
_db.Banlists.Add(banlist);
_db.SaveChanges();
var canBeUsed = _banlistService.CanDeckBeUsedOnGivenBanlist(decklist, banlist);
Assert.IsTrue(canBeUsed);
}
public async Task GetByIdWithAllDataIncluded_ThereIsDecklistWithGivenId_WeGetDecklistWithAllDatas()
{
var banlist = new Banlist("2019.11 TCG", 1);
var archetype = new Archetype("Valid archetype", false);
var bannedPendulumMonster = _helper.GetCard(archetype);
bannedPendulumMonster.MonsterCard = _helper.GetMonsterCard(bannedPendulumMonster);
bannedPendulumMonster.MonsterCard.PendulumMonsterCard = _helper.GetPendulumMonsterCard(bannedPendulumMonster.MonsterCard);
banlist.ForbiddenCards.Add(bannedPendulumMonster);
var limitedLinkMonster = _helper.GetCard(archetype);
limitedLinkMonster.MonsterCard = _helper.GetMonsterCard(limitedLinkMonster);
limitedLinkMonster.MonsterCard.LinkMonsterCard = _helper.GetLinkMonsterCard(limitedLinkMonster.MonsterCard);
banlist.LimitedCards.Add(limitedLinkMonster);
var decklist = _helper.GetValidDecklistWithStatistics(archetype);
decklist.MainDeck.Add(bannedPendulumMonster);
decklist.ExtraDeck.Add(limitedLinkMonster);
_db.Archetypes.Add(archetype);
_db.Banlists.Add(banlist);
_db.Cards.Add(bannedPendulumMonster);
_db.Cards.Add(limitedLinkMonster);
_db.Decklists.Add(decklist);
await _db.SaveChangesAsync();
_initService();
var decklistFromDb = await _decklistService.GetByIdWithAllDataIncluded(1);
Assert.Multiple(() => {
Assert.NotZero(decklistFromDb.Archetype.Name.Length);
Assert.NotZero(decklistFromDb.DecklistStatistics.Count);
Assert.NotZero(decklistFromDb.DecklistStatistics.Count);
Assert.NotNull(decklistFromDb.MainDeck.FirstOrDefault()?.Archetype);
Assert.NotNull(decklistFromDb.MainDeck.FirstOrDefault()?.MonsterCard.PendulumMonsterCard);
Assert.NotNull(decklistFromDb.ExtraDeck.FirstOrDefault()?.MonsterCard.LinkMonsterCard);
Assert.NotZero(decklistFromDb.MainDeck.FirstOrDefault().BanlistsWhereThisCardIsForbidden.Count);
Assert.NotZero(decklistFromDb.ExtraDeck.FirstOrDefault().BanlistsWhereThisCardIsLimited.Count);
});
Assert.IsNotNull("");
}
public void CanDeckBeUsedOnGivenBanlist_ThereIsMoreThanOneLimitedCardInDecklist_ReturnsFalse()
{
var mainDeck = _generateSimplifiedDeckOfCards(40);
var extraDeck = _generateSimplifiedDeckOfCards(15);
var sideDeck = _generateSimplifiedDeckOfCards(14);
Decklist decklist = _genereateDecklistWithAllRequiredData(mainDeck, extraDeck, sideDeck);
var banlist = new Banlist("2018.05 TCG", 1);
banlist.LimitedCards.Add(mainDeck[4]);
_db.Decklists.Add(decklist);
_db.Banlists.Add(banlist);
_db.SaveChanges();
decklist.SideDeck.Add(_db.Cards.Find(mainDeck[4].Id));
_db.SaveChanges();
var canBeUsed = _banlistService.CanDeckBeUsedOnGivenBanlist(decklist, banlist);
Assert.IsFalse(canBeUsed);
}
public AdminUnbanPanel(Vector2i size, Banlist banlist, INetworkManager networkManager,
IResourceManager resourceManager)
: base("Admin UnBan Panel", size, resourceManager)
{
_networkManager = networkManager;
_resourceManager = resourceManager;
BuildList(banlist);
var closeButton = new Button("Close", _resourceManager)
{
Position = new Vector2i(5, 5)
};
closeButton.Clicked += CloseButtonClicked;
components.Add(closeButton);
Position = new Vector2i((int)(CluwneLib.CurrentRenderTarget.Size.X / 2f) - (int)(ClientArea.Width / 2f),
(int)(CluwneLib.CurrentRenderTarget.Size.Y / 2f) - (int)(ClientArea.Height / 2f));
}
public async Task <Banlist> GetBanlistAsync(BanlistFormats format)
{
var formatStr = format switch
{
BanlistFormats.OCG => "ocgstatus",
BanlistFormats.TCG => "tcgadvstatus",
BanlistFormats.TRAD => "tcgtrnstatus",
_ => null
};
await using var connection = _config.GetYuGiOhDbConnection();
await connection.OpenAsync().ConfigureAwait(false);
var banlist = new Banlist
{
Forbidden = await connection.QueryAsync <string>($"select name from cards where {formatStr} ilike 'forbidden' order by name asc").ConfigureAwait(false),
Limited = await connection.QueryAsync <string>($"select name from cards where {formatStr} ilike 'limited' order by name asc").ConfigureAwait(false),
SemiLimited = await connection.QueryAsync <string>($"select name from cards where {formatStr} ilike 'semi-limited' order by name asc").ConfigureAwait(false)
};
return(banlist);
}
public void GetReleaseDateFromName_NameValid_DatesAreEqual()
{
var banlist = new Banlist("2020.01 BobPatrzy", 1);
Assert.AreEqual(new DateTime(2020, 1, 1), banlist.GetReleaseDateFromName());
}
public void Format_NameValid_WeGetExpectedFormat()
{
var banlist = new Banlist("2020.01 BobPatrzy", 1);
Assert.AreEqual("BobPatrzy", banlist.Format);
}
